commit f07ef9653d103705ce07e5b278fef3978876c5ab Author: Team3 Date: Wed Jul 22 16:12:23 2026 +0200 init diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..153d006 --- /dev/null +++ b/.env.example @@ -0,0 +1,14 @@ +# Nach .env kopieren und Werte setzen. Die .env ist die EINZIGE Stelle, an der +# Modelle stehen — Code enthält keine Defaults und keine Fallbacks (Leitprinzip 2). + +MINIMAX_API_KEY= + +# Rollen-Belegung (Format provider:modell). Start-Belegung: alles MiniMax. +ROLLE_SCHNEIDEN=minimax:minimax/MiniMax-M3 +ROLLE_NACHFASS=minimax:minimax/MiniMax-M3 +ROLLE_SICHTEN=minimax:minimax/MiniMax-M3 +ROLLE_JUDGE=minimax:minimax/MiniMax-M3 + +# Engine-Tuning (optional, Defaults siehe backend/config.py) +# MAX_CONCURRENT_AGENTS=6 +# RAM_MIN_FREE_PCT=20 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d786aa4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.env +__pycache__/ +*.pyc +storage/ +.pytest_cache/ diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..9823269 --- /dev/null +++ b/Makefile @@ -0,0 +1,26 @@ +.PHONY: test scan rescan status dev build web + +test: + cd backend && python3 -m pytest -q + +# Entwicklung: Backend (8100, OHNE --reload — Reload killt laufende Scans) + Vite (5273) +dev: + cd backend && uvicorn server:app --port 8100 & \ + cd frontend && npx vite --port 5273 + +# Produktion: Frontend bauen, dann nur den Server starten (serviert frontend/dist) +build: + cd frontend && npm install && npm run build + +web: + cd backend && uvicorn server:app --port 8100 + +# make scan PROJEKT=/pfad/zum/repo +scan: + python3 -m backend scan $(PROJEKT) + +rescan: + python3 -m backend rescan $(PROJEKT) + +status: + python3 -m backend status diff --git a/README.md b/README.md new file mode 100644 index 0000000..a0f27ec --- /dev/null +++ b/README.md @@ -0,0 +1,331 @@ +# Planer + +Ein System, mit dem ich alle meine Projekte **verstehe, orchestriere und weiterentwickle** — +ohne je die Übersicht zu verlieren, was ein Projekt kann. Wiedereinlesen nach Monaten in +Minuten; Änderungen laufen über ein Agenten-Team, das wie ein Entwicklungsunternehmen +arbeitet, in dem ich der Geschäftsführer bin. + +Dieses Dokument ist die **Referenz der Planung** (Stand 2026-07-09). Das System ist noch +nicht gebaut; wir implementieren schrittweise entlang der Phasen am Ende. Nichts hier ist +Code-Realität, bis es umgesetzt und abgehakt ist. + +Referenz-Projekt: `../creator` — dort sind die Kern-Muster bereits validiert +(generische Kanban-Engine `kanban.py`, Provider-Layer `agents.py`, Judge-Gates, +Resume, Events-Telemetrie, Fake-Agenten für Tests). + +--- + +## Leitprinzipien + +1. **Die Wahrheit wohnt im Projekt-Repo.** Artefakte sind Dateien unter `.planer/` im + jeweiligen Projekt, versioniert mit dem Code. Code-Änderung + Artefakt-Update = ein + Commit (atomarer Sync). Der Planer ist Viewer + Orchestrator, nie Wahrheitsbesitzer; + seine DB hält nur wegwerfbaren Lauf-Zustand und Telemetrie. +2. **Kein LLM als Default oder Fallback — nirgendwo.** Jeder LLM-Schritt hat eine benannte + Rolle; die Zuordnung Rolle → Modell steht ausschließlich in einer zentralen Config, vom + Nutzer per UI gesetzt. Unkonfigurierte Rolle oder Provider nicht erreichbar = Lauf + pausiert mit sichtbarer Meldung. Niemals stiller Wechsel. (Hintergrund: ein stiller + Fallback hat einmal ~40 % des Claude-Abo-Kontingents gekostet.) Mechanisch absichern: + Test greppt nach Modell-IDs außerhalb der Config. +3. **Provider-Unabhängigkeit.** Eigenes Agentensystem (Creator-Bausteine wiederverwenden), + damit jederzeit zwischen Claude (Fable/Opus/Sonnet/Haiku) und MiniMax (M3/M2.7-HS/M2.7) + gewechselt werden kann — später auch lokale LLMs. Der Provider-Fallback in + `creator/backend/agents.py` („routed provider unavailable → run provider") wird NICHT + übernommen. +4. **Mechanisch vor LLM.** Alles, was Skripte prüfen können (Anker-Existenz, Tests, Lint, + Diff-Umfang), läuft ohne Token und vor jedem LLM-Urteil. +5. **Messinvarianz.** Telemetrie und QA messen nur; sie sind nie Teil einer Optimierung. +6. **Die UI zeigt, was Handlung braucht — nicht alles, was passiert.** Autonome Agenten + bleiben Hintergrundrauschen; nur Entscheidungen, Drift und Ergebnisse drängen sich vor. +7. **YAGNI.** Zielbild vollständig planen (dieses Dokument), aber jede Phase baut nur, was + sie braucht. Wachstum gesteuert durch Telemetrie und tatsächlichen Gebrauch. +8. **Scan-Ausschlussliste, Secrets nie lesen.** Der Scan liest `.env`, `node_modules`, + Build-Artefakte etc. grundsätzlich nicht — Fakten zitieren Code, und ein zitierter + API-Key stünde sonst im Klartext im Artefakt (Repo!) und in den Agent-Transkripten. + +--- + +## Wissensschichten (Dateien in `/.planer/`) + +Drei Schichten beantworten drei Fragen: + +### 1. Einheiten — *was der Code tut* (Beleg-Schicht) + +Atomare Codebereiche, MECE über den Code: jede Code-Stelle gehört zu genau einer Einheit. +Schnittregel: das Kleinste mit eigener Verantwortung, in einem Satz beschreibbar — mal +eine Funktion, mal eine Klasse, mal ein zusammengehöriger Block. Der Scan-Agent schneidet +nach dieser Regel (kein Parser); v1 beginnt auf Symbol-Ebene, Kleinkram (Imports, Config) +darf anfangs unzugeordnet bleiben. + +Jede Einheit trägt: +- **Anker**: Pfad + Symbol + Commit-Hash des letzten Scans (stabile Identität; bei + Moves/Renames matcht der Re-Scan nach, statt gelöscht+neu zu melden) +- **Ein-Satz-Beschreibung** (die Verantwortung) +- **Fakten**: belegte Aussagen über das Verhalten +- **Beziehungen/Kanten**: ruft auf / importiert / wird ausgelöst von → andere Einheiten + +### 2. Artefakt-Sichten — *was das Projekt kann* + +Überlappende Sichten auf die Einheiten. Sichten **referenzieren** Einheiten, kopieren nie — +jede Aussage existiert genau einmal. MECE gilt **pro Ebene innerhalb eines Typs**, nie über +Typen hinweg. + +- **Kern**: wenige Sätze + die tragenden Einheiten +- **Features**: Funktionsbereiche (6–10) → Features → Teilfeatures → Einheiten-Referenzen; + jedes Feature mit Flag `kern|rand`. Auf jeder Aufklapp-Ebene stehen 5–15 Dinge, nie 100. +- **Flows**: Titel + Beschreibung + Schrittfolge (jeder Schritt → Einheiten) +- **Architektur**: Komponenten (jede Komponente → Einheiten), Beziehungen aus den Kanten + +### 3. Entscheidungen — *warum es so ist* + +Decision Records in `.planer/entscheidungen/`, eine Datei pro Entscheidung: Frage, Kontext, +Optionen, Wahl, Begründung, betroffene Einheiten/Artefakte. Entstehen aus Eskalationen und +strategischen Weichenstellungen. Fließen als Kontext in künftige Aufgaben, deren +Einheiten/Thema sie berühren — Filter und Verifizierer prüfen auch dagegen. Effekt: die +Eskalationsrate sinkt über die Zeit von selbst. + +### Weitere Dateien + +- `.planer/pruefung.md` — Prüf-/Betriebsanleitung des Projekts: Build-, Test-, Lint- und + Start-Kommandos, bekannte Eigenheiten. Wird beim Scan erfasst; Voraussetzung für die + mechanischen Gates und den Verifizierer. Fehlen Tests, degradiert das Gate **sichtbar** + („keine Tests vorhanden"), nie still. +- `.planer/strategie/.md` — benannte Soll-Entwürfe (siehe Strategie-Bereich) +- `.planer/ideen.md` — Ideen-Backlog, wird im Jour Fixe wieder aufgelegt +- `.planer/jourfixe/` — Kurzprotokolle der Sitzungen (Anknüpfpunkt für die nächste) + +--- + +## Scan & Drift + +- **Erst-Scan**: Voll-Analyse des Repos → Einheiten schneiden → Fakten + Kanten extrahieren + → Sichten aggregieren (Barriere: braucht alle Einheiten) → QA. Läuft als Kanban-Board. +- **Re-Scan**: `git diff` seit dem letzten Scan gegen die Anker → nur berührte Einheiten + neu prüfen → nur Artefakte prüfen, die diese Einheiten referenzieren. Billig. +- **Qualitätssicherung zweistufig**: mechanische Gates zuerst und tokenfrei (existiert der + Anker? steht an der Stelle dieser Code? Abdeckung?), LLM-Judge nur für Semantik (stimmt + Beschreibung, sind Fakten korrekt gefolgert). Dadurch ist MiniMax als Scan-Generator gut + abgesichert. +- **Drift-Anzeige**: veraltete Artefakte tragen ein Badge mit Re-Scan-Knopf; Drift-Ampel + je Projekt auf der Startseite. + +--- + +## Der Änderungs-Kreislauf (Kern-Flow) + +``` +Ich entscheide (Strategie / Jour Fixe / Chatbox) + → bestätigter Soll-Diff (Artefakt-Ebene: Features neu/geändert/entfernt) + → Plan-Agent zerlegt in kleine Aufgaben (Schnittgrenze = Einheiten, + prüfbares Fertig-Kriterium, relevante Decision Records angehängt) + → Team-Board arbeitet ab (siehe unten), Eskalationen landen bei mir + → Integrations-Verifikation gegen den urspr. Soll-Diff + (fängt Zerlegungsfehler, die Einzel-Verifizierer nicht sehen) + → Artefakt-Sync (Re-Scan des Diffs, Einheiten + Sichten aktualisieren) + → Commit (Code + Artefakte atomar), Anker auf neuen Commit-Hash +``` + +Scan, Board und Sync arbeiten **nur auf sauberem Working Tree** — uncommittete Änderungen +im Projekt = Abbruch mit Meldung, sonst vermischen sich Agenten-Diffs mit Handarbeit und +der Anker-Commit stimmt nicht mehr. + +Der Commit passiert **immer erst nach dem Artefakt-Sync** — sonst bricht „der Planer hat +die Wahrheit" bei jeder Änderung. Änderungen über den Planer halten die Artefakte per +Konstruktion aktuell; der Drift-Check ist nur das Netz für Änderungen daran vorbei +(die dank Artefakten im Repo + Projekt-Skill ebenfalls mitpflegen können). + +## Team-Board (Ausführung) + +Kanban-Board (Engine aus dem Creator): Karten = Aufgaben, Stufen: + +1. **Umsetzer** ändert Code für genau seine Aufgabe +2. **Mechanische Gates** (tokenfrei, Kommandos aus `.planer/pruefung.md`): Tests grün, + Lint/Format, Diff berührt nur die Einheiten der Aufgabe (Scope-Creep-Check), + Diff-Größe plausibel +3. **LLM-Stil-Filter** (je eigene Rolle, billige Modelle): kein Aufblähen, minimale + Änderung, voller Umfang der Aufgabe — *erst ab v2, wenn Telemetrie zeigt, welche* +4. **Verifizierer** (starkes Modell, frischer Kontext — nie der Umsetzer-Kontext): führt + aus/testet, prüft Verhalten gegen Aufgabe + Soll-Artefakte + Decision Records + +Regeln: +- **Ablehnung** → Befunde-Liste zurück an den Umsetzer (Repair-Muster: Befunde gezielt + abarbeiten, nicht neu würfeln). **Max 2 Runden**, dann Eskalation (Kostenschutz). +- **Fehlende Info/Entscheidung** = sofortige Eskalation, ohne Rate-Runden. +- **Eskalationen kommen entscheidungsreif** an: Blocker + 2–3 Optionen mit Trade-offs + + Empfehlung. Meine Antwort wird automatisch Decision Record, die Karte läuft damit weiter. +- Aufgaben mit **disjunkten Einheiten dürfen parallel** laufen (ab v2; v1 sequenziell). +- Filter, die wiederholt ablehnen, was ich durchwinke → Prompt schärfen statt mehr Runden + (Judges rauschen — Creator-Lehre). + +## Gesprächsmodi (vier, klar getrennt) + +| Modus | Zweck | Ergebnis fließt in | +|---|---|---| +| **Chatbox** | jetzt ändern: Änderung beschreiben → Soll-Diff-Vorschau in den Artefakten → bestätigen → Board | Auftrag | +| **Strategie** | Zukunft entwerfen: mit Agent (`stratege`) Soll-Entwürfe ausarbeiten; Live-Vorschau = Feature-Baum mit neu/geändert/entfernt-Badges; mehrere benannte Szenarien, reifen über Sitzungen | etappenweise Soll-Diffs (Roadmap), Decision Records | +| **Jour Fixe** | rückblickend verbessern: Agent (`berater`) eröffnet datenbasiert (Agenda aus Telemetrie: Eskalationen/Runden, Drift, Kosten, Ideen-Backlog) | Aufträge, Decision Records, `ideen.md`, Protokoll | +| **Eskalation** | blockierte Entscheidung aus dem Board | Decision Record, Karte läuft weiter | + +Chatbox und Strategie sind technisch **eine Komponente in zwei Modi** (sofort ausführen +vs. Entwurf pflegen) — gleiche Diff-Engine, gleiche Vorschau. + +## Rollen & Modelle + +Zentrale Rollen-Tabelle (einzige Stelle mit Modellnamen), per UI-Switch gesetzt, Override +pro Lauf möglich. Rollen mindestens: `scan-schneiden`, `fakten`, `judge`, `plan`, +`umsetzer`, `stil-filter-*`, `verifizierer`, `integrations-verifizierer`, `executor`, +`chat`, `stratege`, `berater`. + +- **Start-Belegung: ALLE Rollen auf MiniMax** (der Betreiber hat dort viele Tokens zum + Testen). Claude kommt nur in eine Rolle, wenn der Betreiber sie bewusst umschaltet. +- Erwartung aus Phase 0: Für Plan/Verifizierer/Stratege/Berater wird sich ein stärkeres + Modell lohnen — aber der Wechsel passiert datenbasiert per Telemetrie, nicht vorab. +- Vor jedem Lauf zeigt die UI die komplette Rollen-Belegung zum Bestätigen; jeder laufende + Agent zeigt sein Modell + +## Telemetrie (Planer-DB, nicht Repo) + +- Je Call: Rolle, Modell, Provider, Tokens rein/raus, Dauer, Status, Projekt, Karte, Stufe +- Je Aufgabe: Runden, Filter-/Verifizierer-Urteile mit Grund, eskaliert + Grund +- Je Eskalation: meine Entscheidung (Muster-Erkennung: gleiche Frage-Kategorie mehrfach → + Kandidat für Decision Record/Regel) +- Agent-Transkripte je Lauf aufbewahren (prunebar) — Urteile müssen nachlesbar sein +- Zweck: datenbasierte Modellwahl je Rolle („MiniMax 1,6 Runden vs. Sonnet 1,1 bei 40 % + der Kosten"), Filter-Tuning, Kosten-Dashboard, Jour-Fixe-Agenda + +## UI + +- **Startseite = Geschäftsführer-Schreibtisch** (Orchestrieren): oben Entscheidungsliste + (Eskalationen, entscheidungsreif), darunter laufende Aufträge über alle Projekte + (Fortschritt, Modelle, Token), darunter Projektliste mit Drift-Ampel und letztem Scan. +- **Projektansicht** (Verstehen): Einstieg über den Kern, aufklappbare Hierarchie + Funktionsbereiche → Features → Teilfeatures → Einheiten (Fakten, Anker); Tabs für Flows, + Architektur, Entscheidungen; Drift-Badges inline mit Re-Scan-Knopf. +- **Doku-Sicht** (Wiedereinlesen): Lesemodus derselben Daten in Einlese-Reihenfolge + (Kern → Architektur → Bereiche in Abhängigkeitsreihenfolge aus den Kanten). Reine Sicht, + keine eigenen Inhalte — kann nie veralten. +- **Chatbox** in der Projektansicht; Soll-Diff-Vorschau direkt in den Artefakten. +- **Strategie-Bereich**: Chat links, Feature-Baum mit Live-Änderungs-Badges in der Mitte. +- **Rechte Seitenleiste**: Live-Status des Boards (Karten je Stufe, aktive Agenten mit + Modell/Laufzeit, Befunde); Eskalationen erscheinen hier UND auf der Startseite. + +## Verwendete Systeme + +Bewusst der Creator-Stack — der Planer unterscheidet sich durch sein Konzept, nicht durch +seine Technik; neue Technologie wäre Lernaufwand an der falschen Stelle. + +- **Backend**: Python, FastAPI, uvicorn, aiosqlite — gesetzt durch die Wiederverwendung + von `kanban.py`/`agents.py`; Fake-Agenten-Ansatz für Tests übernehmen. +- **LLM-Anbindung**: CLI-Subprozesse, keine direkten APIs. `claude`-CLI (läuft über das + Abo via OAuth-Token — die Anthropic-API würde separat kosten), `opencode`-CLI für + MiniMax. Der Executor ist dieselbe Claude-CLI headless (`claude -p`). +- **Frontend**: Vue 3 + Vite, ohne UI-Framework (Muster für Live-Fortschritt, laufende + Agenten, Dark Mode aus dem Creator kopieren; `marked` fürs Artefakt-Rendering). + Komponentenbibliothek erst, wenn konkret etwas fehlt. +- **Daten**: SQLite nur für Betrieb (Telemetrie, Karten, Lauf-Zustand — wegwerfbar). + Artefakte als Markdown mit YAML-Frontmatter in `.planer/` (menschenlesbar, parsebar, + diff-freundlich; Format-Details in Phase 0). +- **Git**: nackte git-CLI + Worktrees für den Executor, keine Bibliothek. +- **Deployment**: Makefile lokal, Docker optional für den Server (Setup vom Creator). +- **Projekt-Verortung**: Projekte bleiben, wo sie sind (z. B. `~/projects/*`) — der Planer + hält nur eine konfigurierte Pfadliste, kein Unterordner-Zwang. + +## Spiel-Verpackung (reine Präsentationsschicht) + +Umschaltbarer Skin über derselben UI und denselben Daten — **keine eigene Mechanik, keine +Punkte/Levels/Achievements** (Goodhart-Gefahr, verletzt Messinvarianz). Metaphern sind 1:1 +isomorph zur Realität: +- Budget = echte Token-Kosten (einziges festes „Spielsystem", weil real) +- Einstellen = Rollen-Tabelle („teurer Senior Fable oder Junior M2.7?"), + Leistungsbeurteilung = Telemetrie je Modell +- Personas mit festen Namen je Rolle (macht Logs/Seitenleiste lesbarer) +- Werkbank = Chatbox, Vorstandsklausur = Strategie, Quartalsgespräch = Jour Fixe, + Posteingang = Eskalationen, Abteilungen = Projekte + +--- + +## Dogfooding: der Planer ist das erste Projekt des Systems + +Der Planer verwaltet sich selbst — gestaffelt, um das Henne-Ei-Problem zu umgehen: + +- **Phase 0 validiert am Creator** (der Planer hat noch keinen Code; der Scan muss sich an + einem großen, gewachsenen Repo beweisen). +- **Ab Phase 1** ist der Planer erstes gescanntes Projekt: Er scannt sich selbst, die + Artefakte werden gegen diese README geprüft — Abweichung heißt Scan schlecht ODER Plan + veraltet, beides will man wissen. Die `.planer/`-Artefakte wachsen ab Commit eins mit + (Soll-first: die Feature-Sicht kann aus dieser README abgeleitet werden, bevor der Code + existiert). +- **Ab Phase 3** laufen Änderungen am Planer durch den Planer selbst. + +**Regel für Selbst-Änderungen** (Creator-Lehre „kein Backend-Edit bei laufendem Flow"): +Der Executor arbeitet immer in einem Worktree/Branch — nie im laufenden Checkout. Gemergt +und neu gestartet wird erst, wenn das Board durch ist; sonst killt der Server-Reload die +eigenen Läufe. + +## Implementierungsphasen + +Jede Phase liefert eigenständigen Nutzen. Erst abhaken, dann weiter. + +### Phase 0 — Scan validieren (kein App-Code) ✅ (2026-07-09) +Die einzige Komponente ohne Creator-Präzedenzfall ist die Scan-Qualität. Alles steht auf ihr. +- [x] `.planer/`-Dateiformat definieren (Einheiten, Sichten — Markdown/YAML) → `docs/format.md` +- [x] Scan-Prompts von Hand am Creator-Repo ausprobieren (MiniMax) → `phase0/` (Prompts, Beispiele) +- [x] Mechanische Prüfskripte: Anker-Existenz, Zitat-Treue → `phase0/pruefe.py` +- [x] Bewerten → mechanisch bestanden (M3: 0 Fehler nach Nachfass; Feature-Sicht: 0 kaputte + Referenzen). Nutzer-Urteil zur Lesbarkeit folgt im echten Viewer (Phase 2). + Alle Befunde: `phase0/erkenntnisse.md` (13 Erkenntnisse, u. a. M3 statt M2.7-HS, + Chunking-Pflicht, Stagger-Sperre, Infra-Fehlerklassen) + +### Phase 1 — Scan-Pipeline ✅ (2026-07-09) +- [x] Kanban-Engine + Provider-Layer aus dem Creator übernehmen (Fallback entfernen!) +- [x] Rollen-Tabelle als Config, harter Stopp bei unkonfigurierter Rolle +- [x] Fake-Agenten von Anfang an (Creator-Muster) — Pipeline ohne LLM in Sekunden testbar +- [x] Scan-Board: schneiden → Fakten/Kanten → Sichten (Barriere) → mechanische Gates → Judge +- [x] Scan erfasst `.planer/pruefung.md` (Build/Test/Start-Kommandos je Projekt) +- [x] Scan-Ausschlussliste (`.env`, `node_modules`, Build-Artefakte …) +- [x] Re-Scan über git-Diff gegen Anker, Rename/Move-Matching +- [x] Events-Telemetrie von Anfang an +- [x] An eigenen Projekten laufen lassen (creator-Abnahme bestanden; weitere bei Bedarf) +- [x] Dogfooding: Planer scannt sich selbst — abgehakt auf Nutzer-Entscheid; Lauf folgt nach erstem Commit + +### Phase 2 — Viewer +- [ ] Startseite: Projektliste mit Drift-Ampel, Scan/Re-Scan auslösbar +- [ ] Projektansicht: Kern, aufklappbare Feature-Hierarchie, Tabs Flows/Architektur/Entscheidungen +- [ ] Doku-Sicht (Leseordnung aus Kanten) +- [ ] Rechte Seitenleiste: laufende Scans live + +### Phase 3 — Ändern (der Kern-Kreislauf) +- [ ] Chatbox: Beschreibung → Soll-Diff-Vorschau in den Artefakten → bestätigen +- [ ] Plan-Rolle: Zerlegung in Aufgaben entlang der Einheiten, Decision Records anhängen +- [ ] Team-Board v1: Umsetzer → mechanische Gates → 1 Verifizierer; sequenziell; 2-Runden-Deckel +- [ ] Eskalation v1: Karte pausiert, Antwort im Chat, wird Decision Record +- [ ] Integrations-Verifikation → Artefakt-Sync → Commit durch den Agenten +- [ ] Fake-E2E: kompletter Änderungs-Kreislauf (Soll-Diff → Board → Sync → Commit) ohne + LLM in Sekunden, an einem Test-Repo +- [ ] Executor-Rolle delegiert (Claude Code headless), Schnittstelle: Auftrag + Kontext rein, Diff raus; + arbeitet immer im Worktree/Branch (Selbst-Änderungs-Regel) +- [ ] Dogfooding: Änderungen am Planer laufen ab jetzt durch den Planer selbst + +### Phase 4 — Orchestrieren +- [ ] Startseite zum Schreibtisch ausbauen: Entscheidungsliste, laufende Aufträge +- [ ] Entscheidungsreife Eskalationen (Optionen + Empfehlung, Klick-Entscheidung) +- [ ] Kosten-Dashboard (Tokens je Rolle/Projekt/Woche) +- [ ] Parallele Aufgaben über disjunkte Einheiten + +### Phase 5 — Strategie & Jour Fixe +- [ ] Strategie-Modus der Chat-Komponente: benannte Entwürfe, Live-Feature-Baum, Roadmap-Abfluss +- [ ] Jour Fixe: datenbasierte Agenda aus Telemetrie, Protokoll, Ideen-Backlog +- [ ] LLM-Stil-Filter gezielt nachrüsten (nur was die Telemetrie als Lücke zeigt) + +### Phase 6 — Politur +- [ ] Spiel-Skin (Personas, Budget, Benennungen; umschaltbar) +- [ ] Projektübergreifender Jour Fixe (Muster über alle Projekte) +- [ ] Lokale LLMs als Provider (wenn gebraucht) + +--- + +## Offene Fragen (bei Phase 0/1 klären) + +- Genaues Dateiformat der Einheiten/Sichten (Lesbarkeit vs. maschinelle Diff-Freundlichkeit) +- Rename/Move-Matching: wie viel Aufwand lohnt v1? +- Wie viel Kontext bekommt der Umsetzer (nur Aufgabe + Einheiten, oder mehr)? diff --git a/backend/__main__.py b/backend/__main__.py new file mode 100644 index 0000000..cc00b38 --- /dev/null +++ b/backend/__main__.py @@ -0,0 +1,8 @@ +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) # `python -m backend` von der Wurzel + +from cli import main # noqa: E402 + +main() diff --git a/backend/agents.py b/backend/agents.py new file mode 100644 index 0000000..e3bf525 --- /dev/null +++ b/backend/agents.py @@ -0,0 +1,564 @@ +"""Provider-Layer: LLM-Calls über Claude-CLI, OpenCode-CLI oder direkte MiniMax-API. + +Port aus creator/backend/agents.py mit zwei bewussten Abweichungen: +- KEIN Provider-Fallback: resolve_role(role) kommt vollständig aus der .env; ist eine + Rolle unkonfiguriert oder der Provider nicht nutzbar, wird der Lauf pausiert + (AgentInfraError) — nie still gewechselt (Leitprinzip 2). +- Leere-Ausgabe-Triage (Phase-0-Erkenntnis 13): leerer Text bei rc=0 ist ein Fehler. + OpenCode-Pfad: keine Session in der OpenCode-DB → Netz/Provider → AgentInfraError + (Pause); Session vorhanden → Retry-Fehler (Thinking-Overrun/Stall). + +Der Event-Sink `on_event` wird von außen injiziert (CLI setzt database.add_event) — +dieses Modul bleibt DB-frei. +""" + +import asyncio +import heapq +import logging +import os +import re +import shutil +import signal +import sqlite3 +import tempfile +import time +from contextlib import asynccontextmanager +from pathlib import Path + +import httpx + +from config import (MAX_CONCURRENT_AGENTS, MAX_CONCURRENT_AGENTS_PER_TOPIC, + MAX_CONCURRENT_API_AGENTS, OPENCODE_CONFIG, PROVIDERS, + RAM_MIN_FREE_PCT, resolve_role) + +log = logging.getLogger("planer.agents") + + +class AgentInfraError(Exception): + """Infrastruktur nicht nutzbar (Netz/Provider down, Rolle unkonfiguriert). KEIN + inhaltliches Urteil — der Aufrufer pausiert den Lauf, nie fail-open.""" + + +_active_processes: dict[str, asyncio.subprocess.Process] = {} +_active_api: set[str] = set() # laufende direkte API-Calls (kein Prozess zu killen) +_active_started: dict[str, float] = {} # agent_key → Wandzeit-Start (Live-Anzeige) +_active_labels: dict[str, str] = {} + + +def active_agents(scope_prefix: str | None = None) -> list[dict]: + """Laufende Agenten mit Laufzeit, längste zuerst. → [{key, label, runtime}]""" + now = time.time() + out = [{"key": k, "label": _active_labels.get(k, ""), "runtime": round(now - t, 1)} + for k, t in list(_active_started.items()) + if (k in _active_processes or k in _active_api) + and (not scope_prefix or k.startswith(scope_prefix))] + return sorted(out, key=lambda a: -a["runtime"]) + + +# --- Abbruch (Prefix-basiert) -------------------------------------------------------- +_cancelled_prefixes: set[str] = set() + + +def cancel_scope(prefix: str) -> None: + _cancelled_prefixes.add(prefix) + + +def clear_scope(prefix: str) -> None: + _cancelled_prefixes.discard(prefix) + + +def _scope_cancelled(agent_key: str) -> bool: + return any(agent_key.startswith(p) for p in _cancelled_prefixes) + + +class _PrioritySemaphore: + """Semaphore-Variante: bei knappen Slots gewinnt die NIEDRIGSTE Prioritätszahl + (FIFO innerhalb gleicher Priorität) — frühe Board-Spalten vor späten.""" + + def __init__(self, value: int): + self._value = value + self._waiters: list = [] # Heap aus [priority, seq, future] + self._seq = 0 + + async def acquire(self, priority: int = 100): + if self._value > 0: + self._value -= 1 + return + fut = asyncio.get_event_loop().create_future() + entry = [priority, self._seq, fut] + self._seq += 1 + heapq.heappush(self._waiters, entry) + try: + await fut # release() reicht den Slot direkt weiter (kein value-Increment) + except BaseException: + entry[2] = None # Tombstone: release() überspringt tote Waiter + if fut.done() and not fut.cancelled(): + self.release() # Slot kam exakt vor dem Cancel → weitergeben + raise + + def release(self): + while self._waiters: + entry = heapq.heappop(self._waiters) + if entry[2] is not None and not entry[2].done(): + entry[2].set_result(None) + return + self._value += 1 + + +_batch_sem = _PrioritySemaphore(MAX_CONCURRENT_AGENTS) # Prozess-Tier (~310 MB RSS) +_batch_sem_api = _PrioritySemaphore(MAX_CONCURRENT_API_AGENTS) # API-Tier (~0 RAM) +_topic_sems: dict[str, _PrioritySemaphore] = {} + +# Kleinerer Index = höhere Priorität: Karten fertig machen statt neues WIP öffnen. +_STAGE_PRIORITY = ("sichten", "judge", "nachfass", "schneiden") + + +def _agent_priority(key: str) -> int: + for i, tag in enumerate(_STAGE_PRIORITY): + if f"-{tag}-" in key or key.endswith(f"-{tag}"): + return i + return len(_STAGE_PRIORITY) + + +@asynccontextmanager +async def _batch_gate(scope: str | None, priority: int, api: bool = False): + """Erst der Per-Topic-Slot (fair), dann der GLOBALE Slot nach Priorität. Ein Waiter + hält beim globalen Anstehen nur seinen Topic-Slot. Topic-Cap gilt über beide Tiers.""" + topic_sem = _topic_sems.setdefault(scope, _PrioritySemaphore(MAX_CONCURRENT_AGENTS_PER_TOPIC)) if scope else None + global_sem = _batch_sem_api if api else _batch_sem + if topic_sem is not None: + await topic_sem.acquire(priority) + await global_sem.acquire(priority) + try: + yield + finally: + global_sem.release() + if topic_sem is not None: + topic_sem.release() + + +# Stagger für OpenCode-Starts: gleichzeitige Kaltstarts kollidieren auf der internen +# Session-DB (Phase-0-Erkenntnis 13a: alle hängen, keine Session entsteht). Token-Bucket: +# der Lock vergibt nur den Start-Slot, geschlafen wird außerhalb. +_opencode_start_lock = asyncio.Lock() +_OPENCODE_START_DELAY = float(os.getenv("OPENCODE_START_DELAY", "0.5")) +_opencode_next_start = 0.0 + + +async def _opencode_slot() -> None: + global _opencode_next_start + loop = asyncio.get_running_loop() + async with _opencode_start_lock: + now = loop.time() + start_at = max(now, _opencode_next_start) + _opencode_next_start = start_at + _OPENCODE_START_DELAY + await asyncio.sleep(max(0.0, start_at - now)) + + +# --- RAM-Gate: unter RAM_MIN_FREE_PCT freiem Speicher warten neue CLI-Prozesse --------- +_RAM_GATE_FLOOR = 2 # unter so vielen Läufen: immer zulassen (Deadlock-Schutz) +_RAM_PER_PROC_KB = 350 * 1024 +_RAM_COMMIT_WINDOW_S = 10.0 # frische Zulassungen zählen als schon verbrauchtes RAM +_RAM_POLL_S = 2.0 +_cli_running = 0 +_cli_recent_starts: list[tuple[float, int]] = [] + + +def _meminfo() -> tuple[int, int] | None: + try: + text = Path("/proc/meminfo").read_text() + except OSError: + return None + m = {k: v for k, v in re.findall(r"^(MemTotal|MemAvailable):\s+(\d+)", text, re.MULTILINE)} + if "MemTotal" not in m or "MemAvailable" not in m: + return None + return int(m["MemAvailable"]), int(m["MemTotal"]) + + +async def _ram_gate(agent_key: str, est_kb: int) -> bool: + """True = Start zugelassen (Commit registriert), False = Scope während des Wartens + abgebrochen. Check und Commit-Append im selben synchronen Block (kein await dazwischen).""" + if RAM_MIN_FREE_PCT <= 0: + return True + waited = False + while True: + if _scope_cancelled(agent_key): + return False + mem = _meminfo() + if mem is None or _cli_running < _RAM_GATE_FLOOR: + break + avail_kb, total_kb = mem + now = time.monotonic() + _cli_recent_starts[:] = [(t, kb) for t, kb in _cli_recent_starts + if now - t < _RAM_COMMIT_WINDOW_S] + committed_kb = sum(kb for _, kb in _cli_recent_starts) + if avail_kb - committed_kb >= total_kb * RAM_MIN_FREE_PCT / 100: + break + if not waited: + log.info("agent %s: RAM-Gate wartet (%.0f%% frei)", agent_key, avail_kb * 100 / total_kb) + waited = True + await asyncio.sleep(_RAM_POLL_S) + _cli_recent_starts.append((time.monotonic(), est_kb)) + return True + + +# Capability → Claude --allowedTools / OpenCode-Agent +_CLAUDE_TOOLS = {"full": "Write,Bash,Read,WebSearch,WebFetch", "files": "Read,Bash,Write", + "read": "Read", "none": None} +_OPENCODE_AGENTS = {"full": "full", "files": "files", "read": "readonly", "none": "text"} + + +def _use_text_api(provider: str, model: str, capabilities: str, on_line) -> bool: + """Direkter API-Pfad nur für tool-lose, nicht-streamende MiniMax-Calls — spart den + OpenCode-Prozess (und dessen Stall-/Kaltstart-Probleme). PLANER_TEXT_API=0 = aus.""" + return (capabilities == "none" and on_line is None + and PROVIDERS[provider]["cli"] == "opencode" + and model.split("/", 1)[0] in ("minimax", "minimax-kalt") + and bool(os.environ.get("MINIMAX_API_KEY")) + and os.getenv("PLANER_TEXT_API", "1") != "0") + + +def provider_available(provider: str) -> bool: + cfg = PROVIDERS.get(provider) + if not cfg: + return False + if shutil.which(cfg["cli"]) is None: + return False + env_key = cfg.get("env_key") + if env_key and not os.environ.get(env_key): + return False + return True + + +def _kill(process) -> None: + """Agent + Kindprozesse über die Prozessgruppe killen (Kinder halten sonst die + Pipes offen und blockieren communicate()).""" + try: + os.killpg(os.getpgid(process.pid), signal.SIGKILL) + except (ProcessLookupError, PermissionError): + try: + process.kill() + except ProcessLookupError: + pass + + +def kill_process(agent_key_prefix: str) -> None: + for key, process in list(_active_processes.items()): + if process.returncode is not None: + _active_processes.pop(key, None) + _active_started.pop(key, None) + continue + if key.startswith(agent_key_prefix): + log.debug("kill agent %s", key) + _kill(process) + + +# Event-Sink (CLI injiziert database.add_event). Fire-and-forget je fertigem Agenten. +on_event = None + + +async def run_agent( + agent_key: str, + prompt: str, + timeout: int, + role: str, + capabilities: str = "none", + scope: str | None = None, + on_line=None, + label: str = "", +) -> tuple[int, str, str]: + """Ein LLM-Call der Rolle `role`. → (rc, stdout, stderr). Wirft AgentInfraError, + wenn die Infrastruktur nicht nutzbar ist (Rolle unkonfiguriert, Provider down, + leere Antwort ohne Session) — der Lauf soll dann pausieren, nicht raten.""" + if os.getenv("PLANER_FAKE_AGENTS"): # Sekunden-Smoke: deterministisch statt LLM + import fake_agents + start = time.monotonic() + res = await fake_agents.respond(agent_key, prompt, capabilities) + if on_event is not None and scope is not None: # Telemetrie auch im Fake-Pfad testbar + await on_event(topic=scope, kind="agent", key=agent_key, label=label, + status="ok" if res[0] == 0 else "error", + dur_ms=int((time.monotonic() - start) * 1000), wait_ms=0, + meta={"provider": "fake", "model": "fake", "role": role, "rc": res[0]}) + return res + if _scope_cancelled(agent_key): + return 1, "", "cancelled" + try: + provider, model = resolve_role(role) # NUR aus .env — kein Default, kein Fallback + except RuntimeError as e: + raise AgentInfraError(str(e)) from e + use_api = _use_text_api(provider, model, capabilities, on_line) + if not use_api and shutil.which(PROVIDERS[provider]["cli"]) is None: + raise AgentInfraError(f"CLI '{PROVIDERS[provider]['cli']}' nicht installiert (Provider {provider})") + queued = time.monotonic() + async with _batch_gate(scope, _agent_priority(agent_key), api=use_api): + if _scope_cancelled(agent_key): + return 1, "", "cancelled" + wait_ms = int((time.monotonic() - queued) * 1000) + start = time.monotonic() + status = "error" + rc = None + err_tail = "" + api_tokens = None + try: + log.info("agent %s: %s %s (Rolle %s)", agent_key, provider, model, role) + if use_api: + rc_, out_, err_, api_tokens = await _run_text_api(agent_key, prompt, timeout, model, label=label) + res = (rc_, out_, err_) + elif PROVIDERS[provider]["cli"] == "opencode": + res = await _run_opencode(agent_key, prompt, timeout, model, capabilities, + on_line=on_line, label=label) + res = await _leere_ausgabe_triage(agent_key, res, on_line) + else: + res = await _run_claude_cli(agent_key, prompt, timeout, model, capabilities, label=label) + rc = res[0] + status = "ok" if rc == 0 else ("killed" if rc is not None and rc < 0 else "error") + if rc not in (0, None) and rc >= 0: + err_tail = (res[2] or res[1] or "").strip()[-300:] + return res + except asyncio.TimeoutError: + status = "timeout" + raise + except asyncio.CancelledError: + status = "cancelled" + raise + except AgentInfraError: + status = "infra" + raise + finally: + if on_event is not None and scope is not None: # nie fatal + try: + meta = {"provider": provider, "model": model, "role": role, "rc": rc} + if err_tail: + meta["stderr"] = err_tail + if api_tokens: + meta["tokens"] = api_tokens + elif PROVIDERS[provider]["cli"] == "opencode": + if (tok := await asyncio.to_thread(_session_tokens, agent_key)): + meta["tokens"] = tok + await on_event(topic=scope, kind="agent", key=agent_key, label=label, + status=status, dur_ms=int((time.monotonic() - start) * 1000), + wait_ms=wait_ms, meta=meta) + except Exception: + log.debug("on_event failed", exc_info=True) + + +async def _leere_ausgabe_triage(agent_key: str, res: tuple[int, str, str], on_line) -> tuple[int, str, str]: + """Erkenntnis 13: leerer Text bei rc=0 ist nie ok. Keine OpenCode-Session zum Key → + der Call kam nie beim Provider an (Netz) → AgentInfraError (Lauf pausiert). + Session vorhanden → Thinking-Overrun/Stall → normaler Fehler (Engine-Retry).""" + rc, out, err = res + if rc != 0 or out.strip() or on_line is not None: + return res + tok = await asyncio.to_thread(_session_tokens, agent_key) + if tok is None: + raise AgentInfraError(f"agent {agent_key}: leere Ausgabe ohne OpenCode-Session — Provider/Netz nicht erreichbar") + return 1, "", f"leere Ausgabe (Session vorhanden, output-tokens={tok.get('output')}) — Overrun/Stall" + + +async def _communicate(agent_key: str, cmd: list[str], stdin_data: bytes | None, timeout: int, + stagger: bool = False, on_line=None, label: str = "", + env: dict | None = None, est_kb: int = _RAM_PER_PROC_KB) -> tuple[int, str, str]: + start = time.monotonic() + + async def spawn(): + return await asyncio.create_subprocess_exec( + *cmd, + stdin=asyncio.subprocess.PIPE if stdin_data is not None else asyncio.subprocess.DEVNULL, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.PIPE, + start_new_session=True, # eigene Prozessgruppe → killpg trifft auch Kinder + env=env, + ) + + global _cli_running + if stagger: + if not await _ram_gate(agent_key, est_kb): + return 1, "", "cancelled" + await _opencode_slot() # Gate VOR dem Start-Slot: Zulassungswelle wird trotzdem gespaced + process = await spawn() + if stagger: + _cli_running += 1 + # Kollisionssicheres Tracking: identische Keys bekommen ~n-Suffix (Prefix-Kill matcht weiter) + track_key = agent_key + n = 2 + while track_key in _active_processes: + track_key = f"{agent_key}~{n}" + n += 1 + _active_processes[track_key] = process + _active_started[track_key] = time.time() + _active_labels[track_key] = label + try: + try: + if on_line is not None: + out_chunks: list[str] = [] + + async def _pump(): + async for raw in process.stdout: + s = raw.decode("utf-8", errors="replace") + out_chunks.append(s) + try: + on_line(s) + except Exception: + log.debug("on_line callback failed", exc_info=True) + await asyncio.wait_for(_pump(), timeout=timeout) + await process.wait() + stderr_b = await process.stderr.read() + stdout, stderr = "".join(out_chunks).encode("utf-8"), stderr_b + else: + stdout, stderr = await asyncio.wait_for( + process.communicate(input=stdin_data), + timeout=timeout, + ) + except asyncio.TimeoutError: + _kill(process) + try: + await asyncio.wait_for(process.wait(), timeout=5) + except asyncio.TimeoutError: + pass + log.info("agent %s: timeout after %ds", agent_key, timeout) + raise + log.info("agent %s: exit %s after %.1fs (%d bytes stdout)", + agent_key, process.returncode, time.monotonic() - start, len(stdout)) + return process.returncode, stdout.decode("utf-8", errors="replace"), stderr.decode("utf-8", errors="replace") + finally: + if stagger: + _cli_running -= 1 + if _active_processes.get(track_key) is process: + del _active_processes[track_key] + _active_started.pop(track_key, None) + _active_labels.pop(track_key, None) + + +async def _run_claude_cli(agent_key: str, prompt: str, timeout: int, model: str, + capabilities: str, label: str = "") -> tuple[int, str, str]: + cmd = ["claude", "-p", "--model", model] + tools = _CLAUDE_TOOLS.get(capabilities) + if tools: + cmd += ["--allowedTools", tools] + cmd += ["--dangerously-skip-permissions"] + return await _communicate(agent_key, cmd, prompt.encode("utf-8"), timeout, stagger=True, label=label) + + +_OPENCODE_DB = Path.home() / ".local" / "share" / "opencode" / "opencode.db" + + +def _session_tokens(agent_key: str) -> dict | None: + """Token-Zähler der neuesten OpenCode-Session mit title=agent_key (via run --title). + Best-effort, read-only, nie fatal — None wenn DB/Zeile fehlt. Auch Timeouts haben + Tokens verbraucht; die Verschwendung soll sichtbar bleiben.""" + try: + con = sqlite3.connect(f"file:{_OPENCODE_DB}?mode=ro", uri=True, timeout=1) + try: + row = con.execute( + "SELECT tokens_input, tokens_output, tokens_reasoning," + " tokens_cache_read, tokens_cache_write" + " FROM session WHERE title=? ORDER BY time_created DESC LIMIT 1", + (agent_key,)).fetchone() + finally: + con.close() + except Exception: + return None + if row is None: + return None + keys = ("input", "output", "reasoning", "cache_read", "cache_write") + return {k: int(v or 0) for k, v in zip(keys, row)} + + +async def _run_opencode(agent_key: str, prompt: str, timeout: int, model: str, capabilities: str, + on_line=None, label: str = "") -> tuple[int, str, str]: + # Prompt per Temp-Datei statt argv (ARG_MAX-Schutz bei großen Chunks) + with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False, encoding="utf-8") as f: + f.write(prompt) + prompt_path = Path(f.name) + # Die positionale Message MUSS vor -f stehen (-f ist ein Array-Flag). + cmd = [ + "opencode", "run", + "Folge exakt den Anweisungen in der angehängten Datei. Sie sind der vollständige Auftrag.", + "-m", model, + "--agent", _OPENCODE_AGENTS.get(capabilities, "text"), + "--title", agent_key, # Token-Accounting: verbindet die OpenCode-Session mit unserem Event + "-f", str(prompt_path), + ] + if on_line is not None: + cmd += ["--format", "json"] + env = {**os.environ, "OPENCODE_CONFIG": str(OPENCODE_CONFIG)} + try: + rc, stdout, stderr = await _communicate(agent_key, cmd, None, timeout, stagger=True, + on_line=on_line, label=label, env=env) + return rc, (stdout if on_line is not None else _clean_opencode_output(stdout)), stderr + finally: + prompt_path.unlink(missing_ok=True) + + +# --- Direkter API-Pfad (MiniMax, Anthropic-Messages-Format) --------------------------- +_API_URL = "https://api.minimax.io/anthropic/v1/messages" +_API_VERSION = "2023-06-01" +_API_MAX_TOKENS = 32_000 + + +def _api_model_opts(model: str) -> dict: + """kalt-Route = niedrige Temperatur ohne Thinking; nativ = Endpoint-Defaults. + Bewusst prefix-basiert statt Modell-Tabelle — Modell-IDs gehören nicht in den Code.""" + if model.startswith("minimax-kalt/"): + return {"temperature": 0.3, "thinking": {"type": "disabled"}} + return {} + + +async def _run_text_api(agent_key: str, prompt: str, timeout: int, model: str, + label: str = "") -> tuple[int, str, str, dict | None]: + """→ (rc, text, err, tokens). Tokens direkt aus der Response-usage, auch bei rc!=0 — + Verschwendung bleibt sichtbar. Leere Antwort und max_tokens-Abbruch sind Fehler.""" + body = { + "model": model.split("/", 1)[1], # ohne OpenCode-Provider-Prefix + "max_tokens": _API_MAX_TOKENS, + "messages": [{"role": "user", "content": prompt}], + **_api_model_opts(model), + } + headers = {"x-api-key": os.environ.get("MINIMAX_API_KEY", ""), "anthropic-version": _API_VERSION} + track_key = agent_key + n = 2 + while track_key in _active_api: + track_key = f"{agent_key}~{n}" + n += 1 + _active_api.add(track_key) + _active_started[track_key] = time.time() + _active_labels[track_key] = label + start = time.monotonic() + try: + async with httpx.AsyncClient(timeout=httpx.Timeout(timeout, connect=30)) as client: + resp = await asyncio.wait_for( + client.post(_API_URL, json=body, headers=headers), timeout=timeout) + except httpx.TimeoutException: + raise asyncio.TimeoutError + except httpx.HTTPError as e: + return 1, "", f"{type(e).__name__}: {e}", None + finally: + _active_api.discard(track_key) + _active_started.pop(track_key, None) + _active_labels.pop(track_key, None) + log.info("agent %s: api done after %.1fs", agent_key, time.monotonic() - start) + if resp.status_code != 200: + return 1, "", f"HTTP {resp.status_code}: {resp.text[:300]}", None + data = resp.json() + # Nur Text-Blöcke zählen — Thinking-Blöcke (native Route) werden übersprungen. + text = "".join(b.get("text", "") for b in data.get("content", []) if b.get("type") == "text") + u = data.get("usage") or {} + tokens = {"input": int(u.get("input_tokens") or 0), "output": int(u.get("output_tokens") or 0), + "reasoning": 0, "cache_read": int(u.get("cache_read_input_tokens") or 0), + "cache_write": int(u.get("cache_creation_input_tokens") or 0)} + if not text.strip(): + return 1, "", f"leere Antwort (stop_reason={data.get('stop_reason')})", tokens + err = "stop_reason=max_tokens (abgeschnitten)" if data.get("stop_reason") == "max_tokens" else "" + return 0, text, err, tokens + + +_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m") + + +def _clean_opencode_output(text: str) -> str: + """ANSI-Codes und den führenden Banner ("> agent · model") entfernen.""" + text = _ANSI_RE.sub("", text) + lines = text.splitlines() + while lines and (not lines[0].strip() or lines[0].lstrip().startswith(">")): + lines.pop(0) + return "\n".join(lines).strip() diff --git a/backend/artefakte.py b/backend/artefakte.py new file mode 100644 index 0000000..8e80b14 --- /dev/null +++ b/backend/artefakte.py @@ -0,0 +1,101 @@ +"""Artefakt-Schicht: Scan-Fragmente je Quelldatei zusammensetzen und als +`.planer/`-Dateien ins Ziel-Repo schreiben. Merge arbeitet auf den ROHEN +Markdown-Blöcken (kein Grammatik-Roundtrip — nichts geht verloren). +""" +import re +from pathlib import Path + +_ERGAENZE_RE = re.compile(r"^ergaenze-anker:\s*(\S+)\s+zu\s+(\S+)\s*$", re.M) + + +def datei_pfad(datei_rel: str) -> str: + """Quelldatei → Pfad der Einheiten-Datei unter .planer/ (`/` → `__`). + Bekannte v1-Schwäche: Quellnamen mit `__` können kollidieren.""" + return "einheiten/" + datei_rel.replace("/", "__") + ".md" + + +def _bloecke(text: str) -> dict[str, str]: + """Fragment → {einheiten_id: roher_block}. Blöcke beginnen bei `## `.""" + out: dict[str, str] = {} + aktuelle_id = None + zeilen: list[str] = [] + for zeile in text.splitlines(): + if zeile.startswith("## ") and ("::" in zeile or re.fullmatch(r"## \S+\.\w+", zeile.strip())): + if aktuelle_id is not None: + out[aktuelle_id] = "\n".join(zeilen).rstrip() + aktuelle_id = zeile[3:].strip() + zeilen = [zeile] + elif aktuelle_id is not None and not _ERGAENZE_RE.match(zeile): + zeilen.append(zeile) + if aktuelle_id is not None: + out[aktuelle_id] = "\n".join(zeilen).rstrip() + return out + + +def merge_fragmente(fragmente: list[str]) -> str: + """Fragmente EINER Quelldatei → Rumpf der Einheiten-Datei. Einheiten in Reihenfolge + des ersten Auftretens, Dubletten (gleiche ID) fallen weg; `ergaenze-anker: X zu Y` + aus Nachfass-Antworten wird als `anker: X` in den Block von Y eingefügt.""" + bloecke: dict[str, str] = {} + ergaenzungen: list[tuple[str, str]] = [] + for frag in fragmente: + ergaenzungen += _ERGAENZE_RE.findall(frag) + for eid, block in _bloecke(frag).items(): + bloecke.setdefault(eid, block) + for anker_id, ziel_id in ergaenzungen: + block = bloecke.get(ziel_id) + if block is None: + continue # Ziel existiert nicht — Gate hat das bereits als Fehler gemeldet + kopf, _, rest = block.partition("\n") + if f"anker: {anker_id}" not in block: + bloecke[ziel_id] = f"{kopf}\nanker: {anker_id}\n{rest}" + return "\n\n".join(bloecke.values()) + + +def einheiten_datei(datei_rel: str, rumpf: str, stand: str) -> str: + return f"# Einheiten: {datei_rel}\nstand: {stand}\n\n{rumpf}\n" + + +def lese_stand(text: str) -> str | None: + m = re.search(r"^stand:\s*(\S+)", text, re.M) + return m.group(1) if m else None + + +def alle_ids(text: str) -> set[str]: + """Alle Einheiten-IDs + Zusatz-Anker einer Einheiten-Datei (für Referenz-Gates).""" + ids = {m.group(1) for m in re.finditer(r"^## (\S+)$", text, re.M)} + ids |= {m.group(1) for m in re.finditer(r"^anker:\s*(\S+)\s*$", text, re.M)} + return ids + + +def schreibe_planer(ziel_repo: Path, dateien: dict[str, str]) -> list[Path]: + """Schreibt {relativer_pfad_unter_.planer: inhalt} ins Ziel-Repo. → geschriebene Pfade.""" + geschrieben = [] + for rel, inhalt in sorted(dateien.items()): + pfad = ziel_repo / ".planer" / rel + pfad.parent.mkdir(parents=True, exist_ok=True) + pfad.write_text(inhalt, encoding="utf-8") + geschrieben.append(pfad) + return geschrieben + + +def pruefung_geruest(wurzel: Path, projekt: str) -> str: + """pruefung.md-Gerüst mit einfacher Erkennung (Makefile-Targets, pytest). + Fehlt etwas, steht dort explizit '(keins vorhanden)' — Gates degradieren sichtbar.""" + tests = lint = start = "(keins vorhanden)" + makefile = wurzel / "Makefile" + if makefile.is_file(): + targets = set(re.findall(r"^([\w-]+):", makefile.read_text(encoding="utf-8"), re.M)) + if "test" in targets: + tests = "make test" + if "lint" in targets: + lint = "make lint" + for kandidat in ("dev", "run", "start"): + if kandidat in targets: + start = f"make {kandidat}" + break + elif list(wurzel.rglob("pytest.ini")) or list(wurzel.rglob("conftest.py")): + tests = "pytest" + return (f"# Prüfung: {projekt}\n" + f"tests: {tests}\nlint: {lint}\nstart: {start}\n" + f"hinweise:\n- (vom Scan erzeugtes Gerüst — bitte prüfen und ergänzen)\n") diff --git a/backend/chunker.py b/backend/chunker.py new file mode 100644 index 0000000..86e504c --- /dev/null +++ b/backend/chunker.py @@ -0,0 +1,96 @@ +"""Chunker: zerlegt ein Repo mechanisch (kein LLM) in kartengroße Scan-Aufträge. + +Phase-0-Befund: dateigroße LLM-Calls dauern Minuten und große Dateien stallen — +deshalb Chunks von ~CHUNK_ZEILEN Zeilen, geschnitten ENTLANG von Top-Level-Symbolen +(nie mitten durch eine Funktion). v1 scannt nur Python-Dateien. +""" +import re +from pathlib import Path + +CHUNK_ZEILEN = 250 # Zielgröße; ein einzelnes Riesen-Symbol darf größer sein +ENDUNGEN = {".py"} # v1: nur Python (Creator/Planer-Backends); Rest später + +AUSSCHLUSS_DIRS = {".git", ".planer", "node_modules", "__pycache__", ".pytest_cache", + "dist", "build", "storage", "venv", ".venv", ".idea", ".vscode", + "tests"} # v1: Test-Code erzeugt in den Sichten nur Rauschen +AUSSCHLUSS_DATEIEN = re.compile(r"^\.env") # Secrets: nie lesen (Leitprinzip 8) + +_SYMBOL_RE = re.compile(r"^(?:async\s+)?(?:def|class)\s+(\w+)") + + +def dateien(wurzel: Path) -> list[Path]: + """Scanbare Quelldateien unter `wurzel`, Ausschlussliste angewandt, sortiert.""" + out = [] + for p in sorted(wurzel.rglob("*")): + if not p.is_file() or p.suffix not in ENDUNGEN: + continue + rel = p.relative_to(wurzel) + if any(teil in AUSSCHLUSS_DIRS for teil in rel.parts[:-1]): + continue + if AUSSCHLUSS_DATEIEN.match(p.name): + continue + out.append(p) + return out + + +def symbol_zeilen(zeilen: list[str]) -> list[tuple[int, str]]: + """(zeilennummer_0basiert, symbolname) aller Top-Level-def/class, in Dateireihenfolge.""" + return [(i, m.group(1)) for i, z in enumerate(zeilen) if (m := _SYMBOL_RE.match(z))] + + +def top_level_symbole(text: str) -> set[str]: + """Alle Top-Level-Symbole (def/class/Konstanten) — Abdeckungs-Referenz für Gates.""" + out = {name for _, name in symbol_zeilen(text.splitlines())} + out |= {m.group(1) for m in re.finditer(r"^(\w+)\s*[:=]", text, re.M)} + return out + + +def _block_start(zeilen: list[str], symbol_zeile: int) -> int: + """Dekoratoren/Kommentare direkt über dem Symbol gehören zum Block.""" + i = symbol_zeile + while i > 0 and (zeilen[i - 1].startswith("@") or zeilen[i - 1].lstrip().startswith("#")): + i -= 1 + return i + + +def schneide(datei_rel: str, text: str) -> list[dict]: + """Datei → Chunks entlang Top-Level-Symbolen, je ~CHUNK_ZEILEN Zeilen. + Chunk: {datei, start, ende (exklusiv, 0-basiert), symbole, text, groesse}. + Der Kopf vor dem ersten Symbol (Docstring/Imports/Konstanten) gehört zum ersten Chunk.""" + zeilen = text.splitlines() + symbole = symbol_zeilen(zeilen) + if not symbole: # Datei ohne def/class (Config, __init__): ein Chunk, Datei-Anker + return [{"datei": datei_rel, "start": 0, "ende": len(zeilen), + "symbole": [], "text": text, "groesse": len(zeilen)}] if zeilen else [] + + # Schnittpunkte: Blockanfänge der Symbole; Kopf hängt am ersten Block. + grenzen = [( _block_start(zeilen, z), name) for z, name in symbole] + chunks: list[dict] = [] + start = 0 + aktuelle_symbole: list[str] = [] + for idx, (block_start, name) in enumerate(grenzen): + naechster = grenzen[idx + 1][0] if idx + 1 < len(grenzen) else len(zeilen) + if aktuelle_symbole and (naechster - start) > CHUNK_ZEILEN: + # Symbol beginnt neuen Chunk, sonst würde der aktuelle zu groß + chunks.append(_chunk(datei_rel, zeilen, start, block_start, aktuelle_symbole)) + start = block_start + aktuelle_symbole = [] + aktuelle_symbole.append(name) + chunks.append(_chunk(datei_rel, zeilen, start, len(zeilen), aktuelle_symbole)) + return chunks + + +def _chunk(datei: str, zeilen: list[str], start: int, ende: int, symbole: list[str]) -> dict: + return {"datei": datei, "start": start, "ende": ende, "symbole": list(symbole), + "text": "\n".join(zeilen[start:ende]), "groesse": ende - start} + + +def chunks_fuer_repo(wurzel: Path, nur_dateien: set[str] | None = None) -> list[dict]: + """Alle Chunks des Repos; `nur_dateien` (relative Pfade) schränkt ein (Re-Scan).""" + out = [] + for p in dateien(wurzel): + rel = str(p.relative_to(wurzel)) + if nur_dateien is not None and rel not in nur_dateien: + continue + out.extend(schneide(rel, p.read_text(encoding="utf-8", errors="replace"))) + return out diff --git a/backend/cli.py b/backend/cli.py new file mode 100644 index 0000000..ccba06c --- /dev/null +++ b/backend/cli.py @@ -0,0 +1,119 @@ +"""CLI des Planers (Phase 1, kein Server): + + python -m backend scan Erst-Scan eines Projekt-Repos + python -m backend rescan Re-Scan über git-Diff gegen die Anker-Stände + python -m backend status Karten-Stände aller bekannten Läufe +""" +import argparse +import asyncio +import logging +import os +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) # `python -m backend` von der Wurzel + +import agents # noqa: E402 +import database as db +import scan_dienst + +log = logging.getLogger("planer") + + +def _abbruch(meldung: str) -> "NoReturn": # noqa: F821 + print(f"ABBRUCH: {meldung}", file=sys.stderr) + sys.exit(1) + + +def _vorflug(wurzel: Path) -> str: + try: + return scan_dienst.vorflug(wurzel) + except scan_dienst.VorflugFehler as e: + _abbruch(str(e)) + + +def _fortschritt(text: str) -> None: + print(f" {text}", flush=True) + + +def _bericht(ergebnis: dict) -> None: + print(f"Status: {ergebnis['status']}") + if ergebnis.get("infra_error"): + print(f" Infra: {ergebnis['infra_error']}") + for pfad in ergebnis.get("geschrieben", []): + print(f" geschrieben: .planer/{pfad}") + for card in ergebnis.get("dead", []): + print(f" DEAD: {card} (requeue über erneuten Lauf oder DB)") + if ergebnis["status"] == "ok": + print("Artefakte aktualisiert — jetzt committen (Code + .planer/ atomar).") + + +async def _scan(wurzel: Path, fortsetzen: bool = False) -> int: + stand = _vorflug(wurzel) + await db.init_db() + agents.on_event = db.add_event + import scan_board + ergebnis = await scan_board.run_scan(wurzel, wurzel.name, stand, set_p=_fortschritt, + fortsetzen=fortsetzen) + _bericht(ergebnis) + return 0 if ergebnis["status"] == "ok" else 1 + + +async def _rescan(wurzel: Path) -> int: + stand_neu = _vorflug(wurzel) + await db.init_db() + agents.on_event = db.add_event + try: + ergebnis = await scan_dienst.rescan_lauf(wurzel, wurzel.name, stand_neu, + set_p=_fortschritt) + except scan_dienst.VorflugFehler as e: + _abbruch(str(e)) + if ergebnis["status"] == "unveraendert": + print("Keine Änderungen seit dem letzten Scan — nichts zu tun.") + return 0 + _bericht(ergebnis) + return 0 if ergebnis["status"] == "ok" else 1 + + +async def _status() -> None: + await db.init_db() + verbindung = await db.get_db() + cursor = await verbindung.execute("SELECT DISTINCT topic FROM kanban_cards ORDER BY topic") + topics = [r[0] for r in await cursor.fetchall()] + if not topics: + print("Keine Läufe in der Planer-DB.") + return + for topic in topics: + counts = await db.kanban_stage_counts(topic) + dead = await db.kanban_dead(topic) + print(f"{topic}: " + ", ".join(f"{s}={n}" for b in counts.values() for s, n in b.items()) + + (f" — DEAD: {[c['card_id'] for c in dead]}" if dead else "")) + + +def main() -> None: + logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s") + # Hänger-Diagnose (offener Befund: Prozess lebt nach Board-Ende weiter): + # `kill -USR1 ` schreibt alle Python-Stacks nach stderr. + import faulthandler + import signal as _signal + faulthandler.register(_signal.SIGUSR1) + parser = argparse.ArgumentParser(prog="planer") + sub = parser.add_subparsers(dest="kommando", required=True) + for name in ("scan", "rescan"): + p = sub.add_parser(name) + p.add_argument("pfad", type=Path) + if name == "scan": + p.add_argument("--fortsetzen", action="store_true", + help="abgebrochenen Lauf fortsetzen (nur tote Chunks neu)") + sub.add_parser("status") + args = parser.parse_args() + if args.kommando == "scan": + sys.exit(asyncio.run(_scan(args.pfad.resolve(), fortsetzen=args.fortsetzen))) + elif args.kommando == "rescan": + sys.exit(asyncio.run(_rescan(args.pfad.resolve()))) + else: + asyncio.run(_status()) + + +if __name__ == "__main__": + main() diff --git a/backend/config.py b/backend/config.py new file mode 100644 index 0000000..44d283d --- /dev/null +++ b/backend/config.py @@ -0,0 +1,72 @@ +"""Konfiguration: Provider-Stacks, Rollen-Auflösung, Engine-Konstanten. + +Rollen-Modelle stehen AUSSCHLIESSLICH in der .env (ROLLE_=provider:modell) — +nirgendwo im Code ein Default oder Fallback. Unkonfigurierte Rolle = harter Stopp. +""" +import os +from pathlib import Path + +PROJECT_ROOT = Path(__file__).resolve().parent.parent +TEMPLATES_DIR = Path(__file__).resolve().parent / "templates" +STORAGE_DIR = PROJECT_ROOT / "storage" +DB_PATH = STORAGE_DIR / "planer.db" +LAEUFE_DIR = STORAGE_DIR / "laeufe" +OPENCODE_CONFIG = PROJECT_ROOT / "dev-ops" / "opencode-slim.json" +PROJEKTE_DATEI = PROJECT_ROOT / "projekte.txt" + + +def _load_env(path: Path) -> None: + """Mini .env-Loader (keine Dependency): KEY=VALUE-Zeilen. Die DATEI gewinnt über + vererbte Env (Creator-Lehre: vererbte Werte pinnen sonst still veraltete Stände).""" + try: + text = path.read_text(encoding="utf-8") + except OSError: + return + for line in text.splitlines(): + line = line.strip() + if not line or line.startswith("#") or "=" not in line: + continue + key, _, value = line.partition("=") + key, value = key.strip(), value.strip().strip('"').strip("'") + if key: + os.environ[key] = value + + +_load_env(PROJECT_ROOT / ".env") + +# --- Provider-Stacks: nur Aufrufweg + Auth, KEINE Modelle ------------------------- +PROVIDERS = { + "claude": {"cli": "claude", "env_key": None}, # Auth via OAuth/~/.claude (Abo) + "minimax": {"cli": "opencode", "env_key": "MINIMAX_API_KEY"}, +} + +# LLM-Rollen des Scan-Boards. Jede braucht ROLLE_ in der .env. +ROLLEN = ("schneiden", "nachfass", "sichten", "judge") + + +def resolve_role(role: str) -> tuple[str, str]: + """→ (provider, modell) aus ROLLE_=provider:modell. Fehlt die Konfiguration + oder ist sie unbrauchbar: RuntimeError — NIE ein stiller Default (Leitprinzip 2).""" + env_name = f"ROLLE_{role.upper()}" + wert = os.getenv(env_name, "").strip() + if not wert: + raise RuntimeError( + f"Rolle '{role}' hat kein Modell konfiguriert — {env_name}=provider:modell in .env setzen") + provider, _, modell = wert.partition(":") + if provider not in PROVIDERS: + raise RuntimeError( + f"{env_name}: unbekannter Provider '{provider}' (bekannt: {', '.join(PROVIDERS)})") + if not modell: + raise RuntimeError(f"{env_name}: Modell fehlt (Format provider:modell)") + return provider, modell + + +# --- Engine-Konstanten (Kanban + Agenten) ----------------------------------------- +KANBAN_BATCH = int(os.getenv("KANBAN_BATCH", "4")) # Karten je Paket +MAX_CARD_RETRIES = int(os.getenv("MAX_CARD_RETRIES", "3")) # dann dead-letter +RETRY_BACKOFF = float(os.getenv("RETRY_BACKOFF", "30")) # Basis-Sekunden, exponentiell +MAX_CONCURRENT_AGENTS = int(os.getenv("MAX_CONCURRENT_AGENTS", "6")) +MAX_CONCURRENT_AGENTS_PER_TOPIC = int(os.getenv("MAX_CONCURRENT_AGENTS_PER_TOPIC", "6")) +MAX_CONCURRENT_API_AGENTS = int(os.getenv("MAX_CONCURRENT_API_AGENTS", "12")) +RAM_MIN_FREE_PCT = int(os.getenv("RAM_MIN_FREE_PCT", "20")) # 0 = RAM-Gate aus +AGENT_TIMEOUT = int(os.getenv("AGENT_TIMEOUT", "360")) # Sekunden je LLM-Call diff --git a/backend/database.py b/backend/database.py new file mode 100644 index 0000000..bb7a625 --- /dev/null +++ b/backend/database.py @@ -0,0 +1,327 @@ +"""Planer-DB: NUR Lauf-Zustand (Kanban-Karten) + Telemetrie (Events) — wegwerfbar. +Die Wahrheit über Projekte liegt als Dateien in deren Repos (.planer/), nie hier. + +Gekürzte Übernahme aus creator/backend/database.py: eine geteilte aiosqlite-Connection, +Schreib-Serialisierung über einen loop-gebundenen Lock (_tx), WAL + busy_timeout. +""" +import asyncio +import json +from contextlib import asynccontextmanager +from datetime import datetime, timedelta, timezone + +import aiosqlite + +import config + +CREATE_KANBAN_CARDS = """ +CREATE TABLE IF NOT EXISTS kanban_cards ( + topic TEXT NOT NULL, + board TEXT NOT NULL, + card_id TEXT NOT NULL, + kind TEXT NOT NULL, + stage TEXT NOT NULL, + payload TEXT NOT NULL DEFAULT '{}', + retries INTEGER NOT NULL DEFAULT 0, + not_before TEXT NOT NULL DEFAULT '', + last_error TEXT, + updated_at TEXT NOT NULL, + PRIMARY KEY (topic, board, card_id) +) +""" + +CREATE_KANBAN_PULL_INDEX = """ +CREATE INDEX IF NOT EXISTS idx_kanban_pull ON kanban_cards(topic, board, stage, not_before, updated_at) +""" + +CREATE_EVENTS = """ +CREATE TABLE IF NOT EXISTS events ( + id INTEGER PRIMARY KEY, + topic TEXT NOT NULL, + ts TEXT NOT NULL, + kind TEXT NOT NULL, + key TEXT NOT NULL DEFAULT '', + label TEXT NOT NULL DEFAULT '', + status TEXT NOT NULL DEFAULT '', + dur_ms INTEGER, + wait_ms INTEGER, + meta TEXT NOT NULL DEFAULT '{}', + run_id TEXT NOT NULL DEFAULT '' +) +""" + +CREATE_EVENTS_INDEX = "CREATE INDEX IF NOT EXISTS idx_events ON events(topic, ts)" +CREATE_EVENTS_RUN_INDEX = "CREATE INDEX IF NOT EXISTS idx_events_run ON events(topic, run_id)" + +_db: aiosqlite.Connection | None = None + + +async def get_db() -> aiosqlite.Connection: + global _db + if _db is None: + config.DB_PATH.parent.mkdir(parents=True, exist_ok=True) + _db = await aiosqlite.connect(config.DB_PATH) + _db.row_factory = None + return _db + + +async def close_db() -> None: + global _db + if _db is not None: + await _db.close() + _db = None + + +_write_lock: asyncio.Lock | None = None +_write_lock_loop: asyncio.AbstractEventLoop | None = None + + +def _get_write_lock() -> asyncio.Lock: + """Lock lazy an den AKTUELLEN Loop gebunden — ein modul-globaler Lock bricht, + wenn Tests jeden Fall in einem frischen Loop fahren.""" + global _write_lock, _write_lock_loop + loop = asyncio.get_running_loop() + if _write_lock is None or _write_lock_loop is not loop: + _write_lock = asyncio.Lock() + _write_lock_loop = loop + return _write_lock + + +@asynccontextmanager +async def _tx(): + """Atomarer Schreibblock: Lock + commit. Nur in Blatt-Funktionen verwenden, + die selbst committen — nie in Funktionen, die andere schreibende rufen.""" + async with _get_write_lock(): + db = await get_db() + try: + yield db + await db.commit() + except BaseException: + try: + await db.rollback() + except Exception: + pass + raise + + +async def init_db() -> None: + db = await get_db() + await db.execute("PRAGMA journal_mode=WAL") + await db.execute("PRAGMA synchronous=NORMAL") + await db.execute("PRAGMA busy_timeout=5000") + await db.execute(CREATE_KANBAN_CARDS) + await db.execute(CREATE_KANBAN_PULL_INDEX) + await db.execute(CREATE_EVENTS) + await db.execute(CREATE_EVENTS_INDEX) + await db.execute(CREATE_EVENTS_RUN_INDEX) + await db.commit() + + +def _now() -> str: + return datetime.now(timezone.utc).isoformat() + + +def _now_plus(seconds: float) -> str: + return (datetime.now(timezone.utc) + timedelta(seconds=seconds)).isoformat() + + +def _row_to_dict(row, cursor) -> dict: + return {d[0]: row[i] for i, d in enumerate(cursor.description)} + + +def _card(row, cursor) -> dict: + """Row → dict mit dekodiertem Payload-JSON (bleibt unter 'payload').""" + d = _row_to_dict(row, cursor) + try: + d["payload"] = json.loads(d.get("payload") or "{}") + except (TypeError, ValueError): + d["payload"] = {} + return d + + +# --- Karten ------------------------------------------------------------------------ + +async def kanban_pull(topic: str, board: str, stage: str, limit: int) -> list[dict]: + """`limit` bereite Karten der Stufe (Backoff abgelaufen). LPT: Karten mit + `groesse`-Payload zuerst (größter Chunk startet früh), sonst FIFO.""" + db = await get_db() + cursor = await db.execute( + """SELECT * FROM kanban_cards WHERE topic = ? AND board = ? AND stage = ? AND not_before <= ? + ORDER BY COALESCE(json_extract(payload, '$.groesse'), 0) DESC, updated_at LIMIT ?""", + (topic, board, stage, _now(), limit)) + return [_card(row, cursor) for row in await cursor.fetchall()] + + +async def kanban_count(topic: str, stages, board: str | None = None) -> int: + """Karten in einer der `stages` (str oder Liste) — Queue-Länge/Quieszenz. + Karten im Backoff zählen mit: ihre Arbeit ist nicht getan.""" + if isinstance(stages, str): + stages = [stages] + if not stages: + return 0 + db = await get_db() + ph = ",".join("?" * len(stages)) + sql = f"SELECT count(*) FROM kanban_cards WHERE topic = ? AND stage IN ({ph})" + args: tuple = (topic, *stages) + if board: + sql += " AND board = ?" + args += (board,) + cursor = await db.execute(sql, args) + return (await cursor.fetchone())[0] + + +async def kanban_advance(topic: str, board: str, card_id: str, stage: str) -> None: + await kanban_advance_many(topic, board, [(card_id, stage)]) + + +async def kanban_advance_many(topic: str, board: str, moves: list[tuple[str, str]]) -> None: + """Batch-Stufenwechsel in EINEM Commit (der Flow advanced ganze Pakete).""" + if not moves: + return + async with _tx() as db: + now = _now() + await db.executemany( + """UPDATE kanban_cards SET stage = ?, retries = 0, not_before = '', last_error = NULL, updated_at = ? + WHERE topic = ? AND board = ? AND card_id = ?""", + [(stage, now, topic, board, cid) for cid, stage in moves]) + await _add_events_many(db, topic, [("stage", f"{board}:{cid}", "", stage) for cid, stage in moves]) + + +async def kanban_upsert_card(topic: str, board: str, card_id: str, kind: str, stage: str, + payload: dict | None = None) -> None: + """Insert oder Overwrite (stabile IDs upserted, nie dupliziert). + payload=None behält bei Konflikt das bestehende Payload.""" + async with _tx() as db: + await db.execute( + """INSERT INTO kanban_cards (topic, board, card_id, kind, stage, payload, updated_at) + VALUES (?, ?, ?, ?, ?, COALESCE(?, '{}'), ?) + ON CONFLICT(topic, board, card_id) DO UPDATE SET + kind = excluded.kind, stage = excluded.stage, + payload = COALESCE(?, kanban_cards.payload), + retries = 0, not_before = '', last_error = NULL, updated_at = excluded.updated_at""", + (topic, board, card_id, kind, stage, + json.dumps(payload, ensure_ascii=False) if payload is not None else None, _now(), + json.dumps(payload, ensure_ascii=False) if payload is not None else None)) + + +async def kanban_set_payload(topic: str, board: str, card_id: str, payload: dict) -> None: + async with _tx() as db: + await db.execute( + "UPDATE kanban_cards SET payload = ?, updated_at = ? WHERE topic = ? AND board = ? AND card_id = ?", + (json.dumps(payload, ensure_ascii=False), _now(), topic, board, card_id)) + + +async def kanban_get_card(topic: str, board: str, card_id: str) -> dict | None: + db = await get_db() + cursor = await db.execute( + "SELECT * FROM kanban_cards WHERE topic = ? AND board = ? AND card_id = ?", (topic, board, card_id)) + row = await cursor.fetchone() + return _card(row, cursor) if row else None + + +async def kanban_cards(topic: str, board: str | None = None, stage: str | None = None, + kind: str | None = None) -> list[dict]: + db = await get_db() + sql, args = "SELECT * FROM kanban_cards WHERE topic = ?", [topic] + for col, val in (("board", board), ("stage", stage), ("kind", kind)): + if val is not None: + sql += f" AND {col} = ?" + args.append(val) + cursor = await db.execute(sql, args) + return [_card(row, cursor) for row in await cursor.fetchall()] + + +async def kanban_fail_card(topic: str, board: str, card_id: str, error: str, + max_retries: int, backoff_base: float = 30.0) -> bool: + """Verarbeitungsfehler: retries++, exponentieller Backoff (not_before), nach + `max_retries` → stage 'dead' (Dead-Letter, requeue-bar). → True wenn dead.""" + async with _tx() as db: + cursor = await db.execute( + "SELECT retries FROM kanban_cards WHERE topic = ? AND board = ? AND card_id = ?", + (topic, board, card_id)) + row = await cursor.fetchone() + if row is None: + return False + retries = (row[0] or 0) + 1 + dead = retries >= max_retries + if dead: + await db.execute( + """UPDATE kanban_cards SET stage = 'dead', retries = ?, not_before = '', + last_error = ?, updated_at = ? WHERE topic = ? AND board = ? AND card_id = ?""", + (retries, error[:500], _now(), topic, board, card_id)) + else: + await db.execute( + """UPDATE kanban_cards SET retries = ?, not_before = ?, last_error = ?, updated_at = ? + WHERE topic = ? AND board = ? AND card_id = ?""", + (retries, _now_plus(backoff_base * (2 ** (retries - 1))), error[:500], _now(), + topic, board, card_id)) + await db.execute( + "INSERT INTO events (topic, ts, kind, key, label, status, dur_ms, wait_ms, meta, run_id) VALUES (?,?,?,?,?,?,?,?,?,?)", + (topic, _now(), "fail", f"{board}:{card_id}", "", "dead" if dead else f"retry{retries}", + None, None, json.dumps({"error": error[:200]}, ensure_ascii=False), _current_run.get(topic, ""))) + return dead + + +async def kanban_dead(topic: str) -> list[dict]: + return await kanban_cards(topic, stage="dead") + + +async def kanban_requeue_dead(topic: str, board: str, stage: str) -> int: + """dead → `stage` (frische Retries). → Anzahl requeueter Karten.""" + async with _tx() as db: + cursor = await db.execute( + """UPDATE kanban_cards SET stage = ?, retries = 0, not_before = '', last_error = NULL, updated_at = ? + WHERE topic = ? AND board = ? AND stage = 'dead'""", + (stage, _now(), topic, board)) + await _add_events_many(db, topic, [("reset", f"{board}:requeue-dead", "", stage)]) + return cursor.rowcount + + +async def kanban_stage_counts(topic: str) -> dict[str, dict[str, int]]: + """{board: {stage: count}} — das Live-Board.""" + db = await get_db() + cursor = await db.execute( + "SELECT board, stage, count(*) FROM kanban_cards WHERE topic = ? GROUP BY board, stage", (topic,)) + out: dict[str, dict[str, int]] = {} + for board, stage, n in await cursor.fetchall(): + out.setdefault(board, {})[stage] = n + return out + + +async def letzter_agent_ts(topic: str) -> str | None: + """Zeitstempel des letzten Agent-Events (auch aus CLI-Läufen — gleiche DB).""" + db = await get_db() + cursor = await db.execute( + "SELECT MAX(ts) FROM events WHERE topic = ? AND kind = 'agent'", (topic,)) + return (await cursor.fetchone())[0] + + +# --- Telemetrie --------------------------------------------------------------------- + +_current_run: dict[str, str] = {} + + +def set_current_run(topic: str, run_id: str | None) -> None: + if run_id: + _current_run[topic] = run_id + else: + _current_run.pop(topic, None) + + +async def add_event(topic: str, kind: str, key: str = "", label: str = "", status: str = "", + dur_ms: int | None = None, wait_ms: int | None = None, meta: dict | None = None) -> None: + """Eine Telemetrie-Zeile, eigener Commit. Aufrufer behandeln das fire-and-forget.""" + async with _tx() as db: + await db.execute( + "INSERT INTO events (topic, ts, kind, key, label, status, dur_ms, wait_ms, meta, run_id) VALUES (?,?,?,?,?,?,?,?,?,?)", + (topic, _now(), kind, key, label, status, dur_ms, wait_ms, + json.dumps(meta or {}, ensure_ascii=False), _current_run.get(topic, ""))) + + +async def _add_events_many(db, topic: str, rows: list[tuple]) -> None: + """Batch-Insert OHNE Commit — muss in der Transaktion des Aufrufers laufen.""" + now = _now() + rid = _current_run.get(topic, "") + await db.executemany( + "INSERT INTO events (topic, ts, kind, key, label, status, dur_ms, wait_ms, meta, run_id) VALUES (?,?,?,?,?,?,?,?,?,?)", + [(topic, now, kind, key, label, status, None, None, "{}", rid) + for kind, key, label, status in rows]) diff --git a/backend/fake_agents.py b/backend/fake_agents.py new file mode 100644 index 0000000..50be657 --- /dev/null +++ b/backend/fake_agents.py @@ -0,0 +1,155 @@ +"""Fake-Welt: deterministische Agenten-Antworten ohne LLM (PLANER_FAKE_AGENTS=1). + +Creator-Muster: eine Welt beantwortet Calls anhand von agent_key-Mustern und kann +Störungen einspielen ({muster, modus, mal}) — damit testet die Fake-E2E den kompletten +Pfad inkl. Retry/Dead-Letter/Pause in Sekunden. +""" +import re + +# Modul-globale Welt für den ENV-Weg; Tests setzen ihre eigene via set_welt(). +_WELT = None + + +def set_welt(welt) -> None: + global _WELT + _WELT = welt + + +class Welt: + def __init__(self): + self.calls: list[str] = [] # Auditspur aller agent_keys + self.stoerungen: list[dict] = [] # {muster, modus: fehler|garbage|infra, mal, [antwort]} + self.antworten: list[tuple[str, object]] = [] # (regex auf agent_key, fn(prompt) -> str) + + def antwort_auf(self, muster: str, fn) -> None: + self.antworten.append((muster, fn)) + + def _stoerung(self, agent_key: str) -> tuple[int, str, str] | None: + for s in self.stoerungen: + if s.get("mal", 0) > 0 and re.search(s["muster"], agent_key): + s["mal"] -= 1 + modus = s.get("modus", "fehler") + if modus == "fehler": + return 1, "", "fake-stoerung" + if modus == "garbage": + return 0, "### kaputtes {fragment", "" + if modus == "infra": + from agents import AgentInfraError + raise AgentInfraError("fake-infra-stoerung") + if modus == "antwort": + return 0, s.get("antwort", ""), "" + return None + + async def respond(self, agent_key: str, prompt: str, capabilities: str) -> tuple[int, str, str]: + self.calls.append(agent_key) + gestoert = self._stoerung(agent_key) + if gestoert is not None: + return gestoert + for muster, fn in self.antworten: + if re.search(muster, agent_key): + return 0, fn(prompt), "" + return 1, "", f"fake: keine Antwort für {agent_key}" + + +async def respond(agent_key: str, prompt: str, capabilities: str) -> tuple[int, str, str]: + global _WELT + if _WELT is None: + _WELT = Welt() + standard_antworten(_WELT) + return await _WELT.respond(agent_key, prompt, capabilities) + + +# --- Standard-Antworten: mechanisch erzeugte Ausgaben, die die ECHTEN Gates bestehen --- + +def _quelle_aus(prompt: str) -> tuple[str, str]: + """(datei, quelltext) aus einem Scan-Prompt (Template-Struktur).""" + m = re.search(r"Ausschnitt aus `(.+?)`\n\n```python\n(.*?)\n?```", prompt, re.S) + return (m.group(1), m.group(2)) if m else ("", "") + + +def _symbol_liste(prompt: str, kopf: str) -> list[str]: + """`- symbol`-Liste direkt nach der Zeile mit `kopf` (Leerzeilen dazwischen erlaubt).""" + idx = prompt.find(kopf) + if idx < 0: + return [] + out: list[str] = [] + for zeile in prompt[idx:].splitlines()[1:]: + z = zeile.strip() + if z.startswith("- "): + if "(keine)" not in z: + out.append(z[2:].strip()) + elif z: + break # erste andere Zeile beendet die Liste + return out + + +def _einheit_fuer(datei: str, symbol: str, quelle: str) -> str: + """Eine gültige Einheit: Beleg = die wörtliche Definitionszeile aus der Quelle.""" + beleg = next((z.strip() for z in quelle.splitlines() + if re.match(rf"\s*(?:async\s+)?(?:def|class)\s+{re.escape(symbol)}\b", z) + or re.match(rf"{re.escape(symbol)}\s*[:=]", z)), "") + beleg = beleg[:60].replace('"', "'") + return (f"## {datei}::{symbol}\n" + f"beschreibung: Fake-Verantwortung von {symbol}.\n" + f"input: Fake-Input\noutput: Fake-Output\n" + f"entscheidungen:\n- Fake-Entscheidung zu {symbol}.\n beleg: \"{beleg}\"\n" + f"kanten:\n") + + +def _fake_schneiden(prompt: str, lasse_aus: set[str]) -> str: + datei, quelle = _quelle_aus(prompt) + symbole = [s for s in _symbol_liste(prompt, "MÜSSEN alle abgedeckt sein") if s not in lasse_aus] + if not symbole: # Datei ohne def/class: erste Konstante als Einheit + m = re.search(r"^(\w+)\s*[:=]", quelle, re.M) + symbole = [m.group(1)] if m else [] + return "\n".join(_einheit_fuer(datei, s, quelle) for s in symbole) + + +def _fake_nachfass(prompt: str) -> str: + datei, quelle = _quelle_aus(prompt) + fehlend = _symbol_liste(prompt, "zugeordnet sind:") + return "\n".join(_einheit_fuer(datei, s, quelle) for s in fehlend) + + +def _ids_aus_uebersicht(prompt: str) -> list[str]: + return re.findall(r"^- (\S+::\S+):", prompt, re.M) + + +def _projekt_aus(prompt: str) -> str: + m = re.search(r"Einheiten von `(.+?)`", prompt) + return m.group(1) if m else "projekt" + + +def _fake_features(prompt: str) -> str: + ids = _ids_aus_uebersicht(prompt) + p = _projekt_aus(prompt) + return (f"# Kern: {p}\nFake-Kern in zwei Sätzen. Mehr Fake.\n\n" + f"tragende-einheiten: {ids[0]}\n\n" + f"# Bereich: fake-bereich\nbeschreibung: Ein Fake-Bereich.\n\n" + f"## Feature: Fake-Feature [kern]\nbeschreibung: Kann alles Fake.\n\n" + f"### Kann fake arbeiten\neinheiten: {', '.join(ids)}\n") + + +def _fake_architektur(prompt: str) -> str: + ids = _ids_aus_uebersicht(prompt) + p = _projekt_aus(prompt) + return (f"# Architektur: {p}\n\n## Komponente: fake-komponente\n" + f"beschreibung: Trägt alles.\neinheiten: {', '.join(ids)}\nbeziehungen:\n") + + +def _fake_flows(prompt: str) -> str: + ids = _ids_aus_uebersicht(prompt) + p = _projekt_aus(prompt) + schritte = "\n".join(f"{i+1}. Fake-Schritt {i+1} — {eid}" for i, eid in enumerate(ids[:3])) + return f"# Flows: {p}\n\n## Flow: fake-ablauf\n{schritte}\n" + + +def standard_antworten(welt: Welt, lasse_aus: set[str] | None = None) -> None: + """Registriert gültige Fake-Antworten für alle Scan-Rollen. `lasse_aus`: Symbole, + die der Erst-Scan absichtlich auslässt (übt den Nachfass-Pfad).""" + aus = lasse_aus or set() + welt.antwort_auf(r"-schneiden-", lambda pr: _fake_schneiden(pr, aus)) + welt.antwort_auf(r"-nachfass-", _fake_nachfass) + welt.antwort_auf(r"-sichten-sicht-features", _fake_features) + welt.antwort_auf(r"-sichten-sicht-architektur", _fake_architektur) + welt.antwort_auf(r"-sichten-sicht-flows", _fake_flows) diff --git a/backend/gates.py b/backend/gates.py new file mode 100644 index 0000000..c520113 --- /dev/null +++ b/backend/gates.py @@ -0,0 +1,310 @@ +"""Mechanische Gates (tokenfrei): prüfen LLM-Scan-Ausgaben gegen den echten Code. + +Port von phase0/pruefe.py als Bibliothek. Phase-0-validiert: fängt erfundene Anker, +umgeschriebene Zitate (auch Minimal-Umformungen) und Format-Drift; Escaping-Rauschen +der Modelle wird vor dem Vergleich normalisiert. +""" +import difflib +import re +from pathlib import Path + +KANTEN_TYPEN = {"ruft-auf", "nutzt", "wird-genutzt-von", "löst-aus", "wird-ausgelöst-von"} + +SCHLUESSEL = ("beschreibung", "input", "output") # Pflichtfelder je Einheit + + +def entschaerfe(s: str) -> str: + """Escaping-Rauschen normalisieren: \\" → \" und \\\\ → \\ (Erkenntnis 11).""" + return s.replace('\\"', '"').replace("\\\\", "\\") + + +def _beleg_text(rest: str) -> str: + """Beleg-Inhalt aus dem Zeilenrest: äußere Anführungszeichen abstreifen, Rest wörtlich. + Kein Quote-Delimiter-Parsing — Belege enthalten selbst Anführungszeichen/Regex + (Abnahme-Befund 17), die Zeile gehört ab `beleg:` komplett dem Zitat.""" + rest = rest.strip() + if len(rest) >= 2 and rest.startswith('"') and rest.endswith('"'): + rest = rest[1:-1] + elif rest.startswith('"'): + rest = rest[1:] + return entschaerfe(rest) + + +def parse_einheiten(text: str) -> tuple[list[dict], list[str], list[str]]: + """Einheiten-Markdown → (einheiten, zusatz_anker, struktur_fehler). + Einheit: {id, zeile, felder: {beschreibung/input/output}, belege: [(nr, zitat)], + kanten: [(nr, typ, ziel)], anker: [ids]}. Streng schreiben, tolerant parsen.""" + einheiten: list[dict] = [] + zusatz_anker: list[str] = [] + fehler: list[str] = [] + aktuelle = None + modus = None + for nr, zeile in enumerate(text.splitlines(), 1): + # Einheiten-Kopf: `## datei::symbol` oder Datei-Einheit `## pfad.py` (Skripte + # ohne def/class — Befund 18) + if zeile.startswith("## ") and ("::" in zeile or re.fullmatch(r"## \S+\.\w+", zeile.strip())): + aktuelle = {"id": zeile[3:].strip(), "zeile": nr, "felder": {}, "belege": [], + "kanten": [], "anker": []} + einheiten.append(aktuelle) + modus = None + elif zeile.startswith(("anker:", "ergaenze-anker:")): + aid = zeile.split(":", 1)[1].strip().split(" zu ")[0].strip() + zusatz_anker.append(aid) + if aktuelle is not None and zeile.startswith("anker:"): + aktuelle["anker"].append(aid) + elif aktuelle is None: + continue + elif m := re.match(r"(beschreibung|input|output):(.*)$", zeile): + aktuelle["felder"][m.group(1)] = m.group(2).strip() + modus = m.group(1) + elif zeile.strip() in ("entscheidungen:", "fakten:"): + modus = "punkte" + elif zeile.strip() == "kanten:": + modus = "kanten" + elif m := re.match(r"\s+beleg:\s*(.+)$", zeile): + aktuelle["belege"].append((nr, _beleg_text(m.group(1)))) + elif modus == "punkte" and (m := re.search(r"\bbeleg:\s*(.+)$", zeile)): + aktuelle["belege"].append((nr, _beleg_text(m.group(1)))) # tolerant: beleg inline + elif modus == "kanten" and (m := re.match(r"- ([\wäöü-]+):\s*(\S+)\s*$", zeile)): + aktuelle["kanten"].append((nr, m.group(1), m.group(2))) + elif modus == "kanten" and zeile.startswith("- "): + fehler.append(f"Z{nr}: Kante unlesbar (Zusatztext?): {zeile.strip()!r}") + return einheiten, zusatz_anker, fehler + + +def _symbol_in_datei(symbol: str, quelle: str, top_level_nur: bool) -> bool: + if "." in symbol: # qualifizierte Methode `Klasse.methode` (Abnahme-Befund) + klasse, _, methode = symbol.partition(".") + return (_symbol_in_datei(klasse, quelle, top_level_nur) + and re.search(rf"def\s+{re.escape(methode)}\b", quelle) is not None) + if top_level_nur: + muster = rf"^(?:async\s+)?(?:def|class)\s+{re.escape(symbol)}\b|^{re.escape(symbol)}\s*[:=]" + else: # Zusatz-Anker dürfen verschachtelt sein (Innenfunktionen, Erkenntnis M3-Lauf) + muster = rf"(?:def|class)\s+{re.escape(symbol)}\b|^{re.escape(symbol)}\s*[:=]" + return re.search(muster, quelle, re.M) is not None + + +def pruefe_fragment(text: str, wurzel: Path, chunk_datei: str, + quelle_cache: dict | None = None) -> tuple[list[str], list[str], list[dict]]: + """Gates für EIN Scan-Fragment: Struktur, Anker-Existenz, Zitat-Treue, Pflichtfelder, + Kanten-Grammatik. → (fehler, warnungen, einheiten). Kanten-ZIELE in fremden Dateien + werden nur auf Datei-Existenz geprüft (das Symbol prüft der Scan der Zieldatei).""" + cache = quelle_cache if quelle_cache is not None else {} + + def quelle(datei: str) -> str | None: + if datei not in cache: + p = wurzel / datei + cache[datei] = p.read_text(encoding="utf-8", errors="replace") if p.is_file() else None + return cache[datei] + + einheiten, zusatz_anker, fehler = parse_einheiten(text) + warnungen: list[str] = [] + if not einheiten: + fehler.append("keine Einheit geparst (Format-Drift oder leere Antwort)") + + def pruefe_id(eid: str, kontext: str, top_level: bool): + datei, _, symbol = eid.partition("::") + q = quelle(datei) + if q is None: + fehler.append(f"{kontext}: Datei fehlt: {datei}") + elif symbol and not _symbol_in_datei(symbol, q, top_level): + fehler.append(f"{kontext}: Symbol '{symbol}' nicht in {datei}") + + for e in einheiten: + kontext = e["id"] + if not e["id"].startswith(chunk_datei + "::") and e["id"] != chunk_datei: + fehler.append(f"{kontext}: Einheit gehört nicht zur gescannten Datei {chunk_datei}") + continue + pruefe_id(e["id"], f"Z{e['zeile']} einheit", top_level=True) + for feld in SCHLUESSEL: + if not e["felder"].get(feld): + (fehler if feld == "beschreibung" else warnungen).append(f"{kontext}: {feld}: fehlt") + q = quelle(chunk_datei) or "" + for nr, beleg in e["belege"]: + if beleg not in q: + fehler.append(f"{kontext} Z{nr}: Zitat nicht wörtlich in {chunk_datei}: \"{beleg[:50]}…\"") + if not e["belege"]: + warnungen.append(f"{kontext}: keine Belege") + for aid in e["anker"]: + pruefe_id(aid, f"{kontext} anker", top_level=False) + for nr, typ, ziel in e["kanten"]: + if typ not in KANTEN_TYPEN: + fehler.append(f"{kontext} Z{nr}: unbekannter Kanten-Typ '{typ}'") + ziel_datei = ziel.partition("::")[0] + if ziel_datei == chunk_datei: + pruefe_id(ziel, f"{kontext} Z{nr} kante", top_level=False) + elif quelle(ziel_datei) is None: + fehler.append(f"{kontext} Z{nr} kante: Datei fehlt: {ziel_datei}") + for aid in zusatz_anker: + if not aid.startswith(chunk_datei + "::"): + fehler.append(f"ergaenze-anker außerhalb der gescannten Datei: {aid}") + return fehler, warnungen, einheiten + + +def fehlende_symbole(chunk_symbole: list[str], einheiten: list[dict], + zusatz_anker: list[str]) -> list[str]: + """Abdeckung eines Chunks: welche seiner Top-Level-Symbole sind keiner Einheit + zugeordnet (weder als ID noch als Anker)?""" + zugeordnet = {e["id"].partition("::")[2] for e in einheiten} + zugeordnet |= {a.partition("::")[2] for a in zusatz_anker} + zugeordnet |= {a.partition("::")[2] for e in einheiten for a in e["anker"]} + return [s for s in chunk_symbole if s not in zugeordnet] + + +def repariere_kanten(fragment: str, wurzel: Path, chunk_datei: str, + quelle_cache: dict | None = None) -> tuple[str, list[str]]: + """Mechanische Reparatur VOR den Gates: Kanten mit ungültigem Ziel (erfundene Datei, + fehlendes Symbol, fehlender datei::-Prefix) werden GESTRICHEN statt das ganze + Fragment scheitern zu lassen — Kanten sind Zusatz-Metadaten, keine Belege. + → (bereinigtes_fragment, gestrichene_zeilen).""" + cache = quelle_cache if quelle_cache is not None else {} + + def quelle(datei: str) -> str | None: + if datei not in cache: + p = wurzel / datei + cache[datei] = p.read_text(encoding="utf-8", errors="replace") if p.is_file() else None + return cache[datei] + + def ziel_ok(ziel: str) -> bool: + if "::" not in ziel: + return False + datei, _, symbol = ziel.partition("::") + q = quelle(datei) + if q is None: + return False + return datei != chunk_datei or _symbol_in_datei(symbol, q, top_level_nur=False) + + gestrichen: list[str] = [] + zeilen_neu: list[str] = [] + for zeile in fragment.splitlines(): + m = re.match(r"- ([\wäöü-]+):\s*(\S+)\s*$", zeile) + if m and m.group(1) in KANTEN_TYPEN and not ziel_ok(m.group(2)): + gestrichen.append(zeile.strip()) + continue + # Freitext hinter einem Kanten-Typ ("- löst-aus: SystemExit bei …") → streichen + m_frei = re.match(r"- ([\wäöü-]+):\s+\S+\s+\S", zeile) + if m_frei and m_frei.group(1) in KANTEN_TYPEN: + gestrichen.append(zeile.strip()) + continue + if zeile.startswith(("anker:", "ergaenze-anker:")): # kaputte Anker-Zeilen ebenso + aid = zeile.split(":", 1)[1].strip().split(" zu ")[0].strip() + datei, _, symbol = aid.partition("::") + q = quelle(datei) if datei else None + if datei != chunk_datei or not symbol or q is None \ + or not _symbol_in_datei(symbol, q, top_level_nur=False): + gestrichen.append(zeile.strip()) + continue + zeilen_neu.append(zeile) + return "\n".join(zeilen_neu), gestrichen + + +_BELEG_RE = re.compile(r"(\bbeleg:\s*)(.+)$") + + +def repariere_belege(fragment: str, wurzel: Path, chunk_datei: str, + quelle_cache: dict | None = None) -> tuple[str, list[str]]: + """Mechanische Zitat-Reparatur: ein Beleg, der nicht wörtlich in der Quelle steht, + wird per Fuzzy-Match auf die ähnlichste Quellzeile GESCHNAPPT und durch deren + wörtlichen Text ersetzt (Abnahme-Befund: Modelle schreiben z. B. `:=` zu `=` um — + ein Zeichen daneben). Unter der Ähnlichkeitsschwelle bleibt der Beleg unverändert + und fällt im Gate durch → Befund-Feedback. → (fragment, korrigierte_belege).""" + cache = quelle_cache if quelle_cache is not None else {} + if chunk_datei not in cache: + p = wurzel / chunk_datei + cache[chunk_datei] = p.read_text(encoding="utf-8", errors="replace") if p.is_file() else None + quelle = cache[chunk_datei] + if quelle is None: + return fragment, [] + zeilen = [z.strip() for z in quelle.splitlines() if z.strip()] + korrigiert: list[str] = [] + + def snap(m: re.Match) -> str: + zitat = _beleg_text(m.group(2)) + if not zitat or zitat in quelle: + return m.group(0) + # Fenster-Matching: Abdeckung des Zitats durch gemeinsame Blöcke mit einer + # Quellzeile — funktioniert auch für kurze Zitate aus langen Zeilen. + beste, beste_deckung = None, 0.0 + for z in zeilen: + sm = difflib.SequenceMatcher(None, zitat.lower(), z.lower(), autojunk=False) + if sm.real_quick_ratio() * max(len(zitat), len(z)) < len(zitat) * 0.8: + continue + bloecke = [b for b in sm.get_matching_blocks() if b.size > 0] + deckung = sum(b.size for b in bloecke) / len(zitat) + if deckung > beste_deckung: + beste_deckung = deckung + start = min(b.b for b in bloecke) + ende = max(b.b + b.size for b in bloecke) + beste = z[start:ende] # wörtliches Quell-Fenster + if beste is None or beste_deckung < 0.8 or beste not in quelle: + return m.group(0) + korrigiert.append(f"{zitat!r} → {beste[:60]!r}") + return m.group(1) + '"' + beste[:78] + '"' + + neu = "\n".join(_BELEG_RE.sub(snap, zeile) for zeile in fragment.splitlines()) + return neu, korrigiert + + +def repariere_referenzen(sichten_text: str, bekannte_ids: set[str]) -> tuple[str, list[str]]: + """Mechanische Reparatur einer Sicht: unbekannte Einheiten-Referenzen werden aus + `einheiten:`-/`tragende-einheiten:`-Zeilen und Flow-Schritten GESTRICHEN; verliert + ein Teilfeature/Schritt alle Referenzen, fällt die Zeile bzw. der `###`-Block weg. + (Abnahme-Befund: Sichten referenzieren Einheiten toter Chunks — per Feedback nicht + heilbar, weil die IDs schlicht nicht existieren.) → (text, gestrichene_refs).""" + gestrichen: list[str] = [] + # Symbol → IDs: falscher Datei-Prefix bei eindeutigem Symbol wird KORRIGIERT statt + # gestrichen (Befund 19: repair.py-Einheit als board_inventory.py referenziert) + je_symbol: dict[str, list[str]] = {} + for eid in bekannte_ids: + je_symbol.setdefault(eid.partition("::")[2], []).append(eid) + + def filtere(refs: str) -> list[str]: + gueltig = [] + for ref in refs.split(","): + ref = ref.strip() + if not ref: + continue + if ref in bekannte_ids: + gueltig.append(ref) + continue + kandidaten = je_symbol.get(ref.partition("::")[2], []) + if len(kandidaten) == 1: + gueltig.append(kandidaten[0]) + else: + gestrichen.append(ref) + return gueltig + + zeilen_neu: list[str] = [] + for zeile in sichten_text.splitlines(): + if m := re.match(r"^(einheiten|tragende-einheiten):\s*(.+)$", zeile): + gueltig = filtere(m.group(2)) + if gueltig: + zeilen_neu.append(f"{m.group(1)}: {', '.join(gueltig)}") + elif m.group(1) == "einheiten" and zeilen_neu and zeilen_neu[-1].startswith("### "): + zeilen_neu.pop() # Teilfeature ohne einzige gültige Referenz fällt weg + else: + zeilen_neu.append(f"{m.group(1)}:") + elif m := re.match(r"^(\d+\.\s.+\s—\s)(.+)$", zeile): + gueltig = filtere(m.group(2)) + if gueltig: + zeilen_neu.append(m.group(1) + ", ".join(gueltig)) + # Schritt ohne gültige Referenz fällt weg + else: + zeilen_neu.append(zeile) + return "\n".join(zeilen_neu), gestrichen + + +def pruefe_referenzen(sichten_text: str, bekannte_ids: set[str]) -> list[str]: + """Referenz-Integrität einer Sicht: `einheiten:`-/`tragende-einheiten:`-Zeilen und + Flow-Schritte (`1. … — id, id`) dürfen nur bekannte Einheiten-IDs nennen.""" + fehler = [] + referenz_zeilen = [m.group(1) for m in + re.finditer(r"^(?:einheiten|tragende-einheiten):\s*(.+)$", sichten_text, re.M)] + referenz_zeilen += [m.group(1) for m in + re.finditer(r"^\d+\.\s.+\s—\s(.+)$", sichten_text, re.M)] + for zeile in referenz_zeilen: + for ref in zeile.split(","): + ref = ref.strip() + if ref and ref not in bekannte_ids: + fehler.append(f"unbekannte Einheiten-Referenz: {ref}") + return fehler diff --git a/backend/kanban.py b/backend/kanban.py new file mode 100644 index 0000000..0ff28f1 --- /dev/null +++ b/backend/kanban.py @@ -0,0 +1,269 @@ +"""Generic streaming kanban engine (no concrete stages — boards define those). + +Each column is a worker that pulls cards from its input `stage` (the queue = kanban_cards rows +WHERE stage = ), processes up to KANBAN_BATCH at a time, and advances them. Streaming +columns run continuously; BARRIER columns start only at QUIESCENCE of every stage before them +(no active worker + no queued card). SERIAL columns process one package at a time (their +processor mutates shared cross-card state). + +Failure handling: a processor exception (including parse-fails it raises) sends the package's +unadvanced cards into exponential backoff (retries++, not_before); after MAX_CARD_RETRIES the +card goes to stage 'dead' (dead-letter — visible on the board, requeue-able via API). No card +is ever deleted by the engine. + +Board definitions live in board_inventory.py / board_artefacts.py; run via run_flow(). +""" + +import asyncio +import logging + +import database as db +from config import KANBAN_BATCH, MAX_CARD_RETRIES, MAX_CONCURRENT_AGENTS_PER_TOPIC, RETRY_BACKOFF +from agents import AgentInfraError + +log = logging.getLogger("creator.kanban") + +# How many packages ONE worker keeps in flight at once. A worker no longer blocks on a single +# package — it keeps pulling and dispatching until this many run concurrently, so a busy column +# fills the agent slots (the per-topic semaphore is the real cap; over-dispatch just queues cheaply). +WORKER_INFLIGHT = MAX_CONCURRENT_AGENTS_PER_TOPIC +_POLL = 0.3 # seconds between empty-queue polls + +# Live registry of running flows (topic → Flow), so routes can attach research agents, +# report `generating`, and cancel. +active_flows: dict[str, "Flow"] = {} + + +class Flow: + """Shared runtime state of one topic run: active-task counters per stage + a wakeup event. + `producers` counts running research agents (initial + any added live); research counts as done + only when ALL producers have finished, so the flow stays awake while extras still search.""" + + def __init__(self, topic: str, work_dir=None): + self.topic = topic + self.work_dir = work_dir + self.active: dict[str, int] = {} + self.producers = 0 + self.producer_tag = 0 + self.stop = False + self.wake = asyncio.Event() + self.spawn_research = None # set by the board: () → coroutine adding one more research agent + self.state: dict = {} # board-private shared state (embedding caches, one-shot flags …) + self.active_cards: set[str] = set() # "board:card_id" currently inside a processor (live display) + + @property + def research_done(self) -> bool: + return self.producers <= 0 + + def add_producer(self): + """MUST be called synchronously BEFORE create_task of the producer — otherwise workers + can pass their exit check in the gap and never see the new producer (quiescence race).""" + self.producers += 1 + self.wake.set() + + def done_producer(self): + self.producers -= 1 + self.wake.set() + + def next_tag(self) -> int: + self.producer_tag += 1 + return self.producer_tag + + def enter(self, stage: str): + self.active[stage] = self.active.get(stage, 0) + 1 + + def leave(self, stage: str): + self.active[stage] = max(0, self.active.get(stage, 0) - 1) + self.wake.set() + + def active_in(self, stages) -> bool: + return any(self.active.get(s, 0) > 0 for s in stages) + + +class Stage: + """One column: board + stage name + processor. `upstream` (all stages before it, across + boards) is filled by chain_stages(). process(cards) gets the pulled package (list of card + dicts with decoded payload). + + barrier: pull only when every upstream stage is quiescent (relational judgements need the + full set). gate: extra callable that must be truthy before the stage pulls (works without + barrier too — e.g. the consensus gate holds cards until research is done so late reader + votes still count). drain: pull the WHOLE queue as one package (global passes like the + fragment filter); implies serial.""" + + def __init__(self, board: str, stage: str, process, *, barrier: bool = False, + serial: bool = False, gate=None, drain: bool = False): + self.board = board + self.stage = stage + self.process = process + self.barrier = barrier + self.serial = serial or drain + self.gate = gate + self.drain = drain + self.upstream: list[str] = [] + + +def chain_stages(stages: list[Stage]) -> list[Stage]: + """Fill each stage's upstream = every stage listed before it (list order = flow order). + Producers are upstream of everything implicitly via flow.research_done.""" + seen: list[str] = [] + for s in stages: + s.upstream = list(seen) + seen.append(s.stage) + return stages + + +async def quiescent(flow: Flow, stages) -> bool: + """True iff no worker is active in `stages` AND no card is queued in any of them. + The barrier/exit condition — must include QUEUED cards, not just active workers, or a worker + could exit in a momentary lull while an upstream worker still has work to push down.""" + if not stages: + return True + if flow.active_in(stages): + return False + return await db.kanban_count(flow.topic, list(stages)) == 0 + + +async def _sleep_wake(flow: Flow): + try: + await asyncio.wait_for(flow.wake.wait(), timeout=_POLL) + except asyncio.TimeoutError: + pass + flow.wake.clear() + + +async def _fail_package(flow: Flow, spec: Stage, cards: list[dict], error: str): + """Backoff/dead-letter for the cards the processor did NOT advance (their stage is unchanged — + advanced cards must not be punished for a failure after their move).""" + for c in cards: + cur = await db.kanban_get_card(flow.topic, spec.board, c["card_id"]) + if cur is None or cur["stage"] != spec.stage: + continue + dead = await db.kanban_fail_card(flow.topic, spec.board, c["card_id"], error, + MAX_CARD_RETRIES, RETRY_BACKOFF) + if dead: + log.warning("kanban %s/%s: card %s → dead (%s)", flow.topic, spec.stage, c["card_id"], error) + + +async def _worker(flow: Flow, spec: Stage, inflight: int, all_stages: list[str]): + """Pull cards from spec.stage, run spec.process — keeping up to `inflight` packages running + CONCURRENTLY so a busy column fills the agent slots. A barrier worker only pulls when upstream + is fully quiescent (and its gate, if any, is open). ANY worker exits only when research is + done and the WHOLE flow is quiescent — global instead of per-stage, so a downstream stage + that feeds cards back upstream (gap-check → ingest) never strands work. Double-checked over + one grace sleep (a producer attached in the lull keeps the flow alive). + + Double-pull safety: each stage has exactly ONE worker, so an in-memory `claimed` set of + card-ids (held while a package runs) keeps concurrent pulls from grabbing the same cards.""" + topic = flow.topic + claimed: set[str] = set() + tasks: set[asyncio.Task] = set() + batch = 100_000 if spec.drain else KANBAN_BATCH + + async def _run(cards): + ids = [c["card_id"] for c in cards] + flow.enter(spec.stage) + flow.active_cards.update(f"{spec.board}:{i}" for i in ids) + try: + await spec.process(cards) + except AgentInfraError as e: # 429/Timeout erschöpft → Lauf pausieren, NICHT dead-letter + log.warning("kanban %s/%s: infra-pause: %s", topic, spec.stage, e) + flow.state["infra_paused"] = True + flow.state["infra_error"] = str(e) + flow.stop = True + flow.wake.set() + except Exception as e: # one bad package must not kill the worker → backoff/dead-letter + log.info("kanban %s/%s: %s: %s", topic, spec.stage, type(e).__name__, e) + try: + await _fail_package(flow, spec, cards, f"{type(e).__name__}: {e}") + except Exception: + log.exception("kanban %s/%s: fail-handling broke", topic, spec.stage) + finally: + flow.leave(spec.stage) + for i in ids: + claimed.discard(i) + flow.active_cards.discard(f"{spec.board}:{i}") + flow.wake.set() + + async def _idle_exit() -> bool: + return (flow.research_done and not flow.active_in(all_stages) + and await db.kanban_count(topic, all_stages) == 0) + + async def _may_pull() -> bool: + if spec.gate is not None and not spec.gate(): + return False + if not spec.barrier: + return True + return await quiescent(flow, spec.upstream) + + try: + while not flow.stop: + tasks = {t for t in tasks if not t.done()} + # Fill the pipeline: pull fresh cards and dispatch until `inflight` packages run. + if await _may_pull(): + while len(tasks) < inflight: + rows = await db.kanban_pull(topic, spec.board, spec.stage, batch + len(claimed)) + fresh = [r for r in rows if r["card_id"] not in claimed][:batch] + if not fresh: + break + for r in fresh: + claimed.add(r["card_id"]) + tasks.add(asyncio.create_task(_run(list(fresh)))) + if tasks: # busy → wait for a package to finish, then refill + await asyncio.wait(tasks, timeout=_POLL, return_when=asyncio.FIRST_COMPLETED) + continue + # idle: nothing in flight and nothing pulled + if await _idle_exit(): + # Real grace sleep (NOT _sleep_wake — the wake event is usually already set + # by the last package and would collapse the window to 0ms). A producer + # attached during the lull flips research_done and keeps us alive. + await asyncio.sleep(_POLL) + if await _idle_exit(): + return # nothing left and nothing upstream can produce + continue + await _sleep_wake(flow) + finally: + for t in tasks: + t.cancel() + if tasks: + await asyncio.gather(*tasks, return_exceptions=True) + + +async def run_flow(flow: Flow, stages: list[Stage], producers=(), set_p=None) -> None: + """Run producers + one worker per stage until global quiescence. `producers` are coroutines + already counted via flow.add_producer() BEFORE this call (quiescence race). Registers the + flow in active_flows for live attach/cancel.""" + active_flows[flow.topic] = flow + names = [s.stage for s in stages] + + def _spawn_workers(): + return [asyncio.ensure_future(_worker(flow, s, 1 if s.serial else WORKER_INFLIGHT, names)) + for s in stages] + + workers = [asyncio.ensure_future(p) for p in producers] + _spawn_workers() + progress = asyncio.create_task(_progress(flow, set_p)) if set_p else None + try: + while True: + await asyncio.gather(*workers, return_exceptions=True) + # Restart round: a producer attached exactly as the workers exited (missed even the + # grace sleep) leaves live producers or queued cards behind → run the workers again. + if flow.stop or (flow.research_done and await quiescent(flow, names)): + break + workers = _spawn_workers() + finally: + flow.stop = True + if progress: + progress.cancel() + if active_flows.get(flow.topic) is flow: + active_flows.pop(flow.topic, None) + + +async def _progress(flow: Flow, set_p): + while not flow.stop: + try: + counts = await db.kanban_stage_counts(flow.topic) + total = sum(n for stages in counts.values() for n in stages.values()) + set_p(f"Kanban: {total} Karten im Fluss") + except Exception: + pass + await asyncio.sleep(1.0) diff --git a/backend/projekte.py b/backend/projekte.py new file mode 100644 index 0000000..62327e8 --- /dev/null +++ b/backend/projekte.py @@ -0,0 +1,36 @@ +"""Projektliste: konfigurierte Pfade aus projekte.txt (eine Zeile = absoluter Pfad, +#-Kommentare). Von Hand editierbar — UI-Verwaltung kommt später (YAGNI).""" +from pathlib import Path + +import config + + +def lade() -> list[dict]: + """→ [{name, pfad, fehler?}]. Toter Pfad oder Basename-Kollision wird als Eintrag + mit `fehler` gemeldet, nie still verschluckt.""" + if not config.PROJEKTE_DATEI.is_file(): + return [] + out: list[dict] = [] + gesehen: dict[str, str] = {} + for zeile in config.PROJEKTE_DATEI.read_text(encoding="utf-8").splitlines(): + zeile = zeile.strip() + if not zeile or zeile.startswith("#"): + continue + pfad = Path(zeile).expanduser() + name = pfad.name + eintrag = {"name": name, "pfad": str(pfad)} + if not pfad.is_dir(): + eintrag["fehler"] = "Pfad existiert nicht" + elif name in gesehen: + eintrag["fehler"] = f"Namenskollision mit {gesehen[name]}" + else: + gesehen[name] = str(pfad) + out.append(eintrag) + return out + + +def finde(name: str) -> Path | None: + for p in lade(): + if p["name"] == name and "fehler" not in p: + return Path(p["pfad"]) + return None diff --git a/backend/pytest.ini b/backend/pytest.ini new file mode 100644 index 0000000..78c5011 --- /dev/null +++ b/backend/pytest.ini @@ -0,0 +1,3 @@ +[pytest] +asyncio_mode = auto +testpaths = tests diff --git a/backend/repo.py b/backend/repo.py new file mode 100644 index 0000000..a6de33d --- /dev/null +++ b/backend/repo.py @@ -0,0 +1,53 @@ +"""git-Helfer (nackte CLI, keine Bibliothek): Anker-Stände und Diff fürs Re-Scannen.""" +import subprocess +from pathlib import Path + + +def _git(wurzel: Path, *args: str) -> str: + res = subprocess.run(["git", "-C", str(wurzel), *args], + capture_output=True, text=True, timeout=30) + if res.returncode != 0: + raise RuntimeError(f"git {' '.join(args)}: {res.stderr.strip() or res.stdout.strip()}") + return res.stdout + + +def ist_repo(wurzel: Path) -> bool: + try: + _git(wurzel, "rev-parse", "--git-dir") + return True + except (RuntimeError, FileNotFoundError): + return False + + +def head_hash(wurzel: Path) -> str: + return _git(wurzel, "rev-parse", "--short=12", "HEAD").strip() + + +def working_tree_sauber(wurzel: Path) -> bool: + """False bei uncommitteten Änderungen (inkl. untracked) — Scan/Board arbeiten nur + auf sauberem Tree, sonst vermischen sich Stände. AUSNAHME `.planer/`: die eigenen + Artefakte (z. B. aus einem Teillauf) dürfen den Folgelauf nicht blockieren.""" + for zeile in _git(wurzel, "status", "--porcelain").splitlines(): + pfad = zeile[3:].split(" -> ")[-1].strip().strip('"') + if not pfad.startswith(".planer/"): + return False + return True + + +def geaenderte_dateien(wurzel: Path, alt: str, neu: str = "HEAD") -> tuple[set[str], set[str]]: + """(geändert_oder_neu, gelöscht) zwischen `alt` und `neu`, `.planer/` ausgefiltert. + Renames (R) = alt gelöscht + neu geändert (v1: kein Anker-Matching über Renames).""" + geaendert: set[str] = set() + geloescht: set[str] = set() + for zeile in _git(wurzel, "diff", "--name-status", f"{alt}..{neu}").splitlines(): + teile = zeile.split("\t") + status = teile[0] + if status.startswith("R") and len(teile) == 3: + geloescht.add(teile[1]) + geaendert.add(teile[2]) + elif status == "D": + geloescht.add(teile[1]) + elif len(teile) >= 2: + geaendert.add(teile[1]) + kein_planer = lambda s: not s.startswith(".planer/") # noqa: E731 + return set(filter(kein_planer, geaendert)), set(filter(kein_planer, geloescht)) diff --git a/backend/routes.py b/backend/routes.py new file mode 100644 index 0000000..6808794 --- /dev/null +++ b/backend/routes.py @@ -0,0 +1,108 @@ +"""API des Viewers (Phase 2). Lese-Routen über viewer.py, Lauf-Routen über scan_dienst.""" +from pathlib import Path + +from fastapi import APIRouter, HTTPException + +import agents +import database as db +import projekte +import scan_dienst +import viewer + +router = APIRouter(prefix="/api") + + +def _wurzel(name: str) -> Path: + wurzel = projekte.finde(name) + if wurzel is None: + raise HTTPException(404, f"Projekt '{name}' nicht in projekte.txt") + return wurzel + + +@router.get("/health") +async def health(): + return {"ok": True} + + +@router.get("/projekte") +async def liste(): + out = [] + for p in projekte.lade(): + eintrag = dict(p) + if "fehler" not in p: + wurzel = Path(p["pfad"]) + eintrag["hat_planer"] = (wurzel / ".planer" / "kern.md").is_file() + staende = {d: s for d, (s, _) in scan_dienst.einheiten_bestand(wurzel).items()} + eintrag["drift"] = viewer.drift(wurzel, staende)["veraltet"] + eintrag["letzter_scan_ts"] = await db.letzter_agent_ts(p["name"]) + lauf = scan_dienst.status(p["name"]) + eintrag["scan_laeuft"] = bool(lauf and lauf["laeuft"]) + out.append(eintrag) + return out + + +@router.get("/projekte/{name}") +async def projekt(name: str): + wurzel = _wurzel(name) + daten = viewer.lade_projekt(wurzel) + einheiten_kurz = {eid: {"beschreibung": e["beschreibung"]} + for eid, e in daten["einheiten"].items()} + return { + "name": name, + "kern": daten["kern"], + "bereiche": daten["bereiche"], + "architektur": daten["architektur"], + "flows": daten["flows"], + "pruefung": daten["pruefung"], + "einheiten": einheiten_kurz, + "doku_ordnung": viewer.doku_ordnung(daten), + "drift": viewer.drift(wurzel, daten["staende"]), + } + + +@router.get("/projekte/{name}/einheit") +async def einheit(name: str, id: str): + wurzel = _wurzel(name) + daten = viewer.lade_projekt(wurzel) + e = daten["einheiten"].get(id) + if e is None: + raise HTTPException(404, f"Einheit '{id}' unbekannt") + quelldatei = id.partition("::")[0] + veraltet = quelldatei in viewer.drift(wurzel, daten["staende"])["veraltet"] + code = viewer.code_extrahieren(wurzel, id) + for anker in e["anker"]: + zusatz = viewer.code_extrahieren(wurzel, anker) + if zusatz and zusatz not in code: + code += ("\n\n" if code else "") + zusatz + return {**e, "code": code, "veraltet": veraltet} + + +@router.post("/projekte/{name}/scan") +async def scan_starten(name: str, body: dict): + wurzel = _wurzel(name) + art = body.get("art", "scan") + if art not in ("scan", "rescan"): + raise HTTPException(400, f"unbekannte Art '{art}'") + try: + status = scan_dienst.starte(name, wurzel, art) + except scan_dienst.VorflugFehler as e: + raise HTTPException(409, str(e)) + return {"status": status} + + +@router.get("/projekte/{name}/scan-status") +async def scan_status(name: str): + _wurzel(name) + lauf = scan_dienst.status(name) + if lauf is None: + return {"laeuft": False, "art": None, "ergebnis": None, "stufen": {}, "agenten": [], "dead": []} + out = dict(lauf) + if lauf["laeuft"]: + out["stufen"] = (await db.kanban_stage_counts(name)).get("scan", {}) + out["agenten"] = agents.active_agents(f"scan-{name}-") + out["dead"] = [c["card_id"] for c in await db.kanban_dead(name)] + else: + out["stufen"] = {} + out["agenten"] = [] + out["dead"] = (lauf["ergebnis"] or {}).get("dead", []) + return out diff --git a/backend/scan_board.py b/backend/scan_board.py new file mode 100644 index 0000000..c6ad1f1 --- /dev/null +++ b/backend/scan_board.py @@ -0,0 +1,319 @@ +"""Scan-Board: zerlegt ein Projekt-Repo in Einheiten und Sichten (.planer/-Dateien). + +Stages (Engine: kanban.py): + Producer (Chunker, mechanisch) → schneiden (LLM je Chunk) → nachfass (LLM, nur bei + Abdeckungslücken) → sammeln (mechanisch, drain: Fragmente je Quelldatei mergen, + Sicht-Karten anlegen) → sichten (LLM je Sicht-Art) → schreiben (mechanisch, drain: + .planer/ ins Ziel-Repo). + +Payload-Disziplin: Chunk-Text und Fragmente bleiben in der Karte (~15 KB), ab `sammeln` +tragen Karten nur noch Staging-Pfade (storage/laeufe//). +""" +import asyncio +import logging +import time +from pathlib import Path + +import artefakte +import chunker +import config +import database as db +import gates +from agents import AgentInfraError, run_agent +from kanban import Flow, Stage, chain_stages, run_flow + +log = logging.getLogger("planer.scan") + +BOARD = "scan" +SICHT_ARTEN = ("features", "architektur", "flows") +MAX_NACHFASS_SYMBOLE = 40 # Notbremse gegen endlos wachsende Nachfass-Prompts + + +def _template(name: str) -> str: + return (config.TEMPLATES_DIR / f"{name}.md").read_text(encoding="utf-8") + + +def _prompt(name: str, **ersetzungen: str) -> str: + text = _template(name) + for k, v in ersetzungen.items(): + text = text.replace(f"<{k}>", v) + return text + + +async def _llm(flow: Flow, stufe: str, card_id: str, rolle: str, prompt: str, label: str) -> str: + """Ein Gate-gesicherter LLM-Call: rc!=0 → ValueError (Engine-Backoff); + AgentInfraError propagiert (Lauf pausiert).""" + rc, out, err = await run_agent( + f"scan-{flow.topic}-{stufe}-{card_id}", prompt, config.AGENT_TIMEOUT, + role=rolle, scope=flow.topic, label=label) + if rc != 0: + raise ValueError(f"{stufe} rc={rc}: {(err or out)[:200]}") + return out + + +class ScanKontext: + def __init__(self, wurzel: Path, stand: str, lauf_dir: Path): + self.wurzel = wurzel + self.stand = stand # HEAD-Hash des Ziel-Repos beim Scan-Start + self.lauf_dir = lauf_dir # Staging: storage/laeufe// + self.quelle_cache: dict = {} # Datei → Text (Gates lesen viel) + self.bestand: dict[str, str] = {} # unveränderte Einheiten-Dateien (Re-Scan) + + +# --- Prozessoren --------------------------------------------------------------------- + +async def _je_karte(flow: Flow, cards: list[dict], verarbeite) -> None: + """Karten eines Pakets parallel verarbeiten; Erfolge advancen, dann ersten Fehler + werfen (nur unadvancte Karten gehen in den Backoff). AgentInfraError hat Vorrang.""" + ergebnisse = await asyncio.gather(*(verarbeite(c) for c in cards), return_exceptions=True) + moves = [(c["card_id"], ziel) for c, ziel in zip(cards, ergebnisse) if isinstance(ziel, str)] + if moves: + await db.kanban_advance_many(flow.topic, BOARD, moves) + flow.wake.set() + fehler = [e for e in ergebnisse if isinstance(e, BaseException)] + for e in fehler: + if isinstance(e, AgentInfraError): + raise e + if fehler: + raise fehler[0] + + +def _mit_befunden(prompt: str, payload: dict) -> str: + """Repair-Muster (Creator-Lehre): der Retry bekommt die Gate-Befunde des letzten + Versuchs — blinde Wiederholung heilt systematische Fehler nicht.""" + befunde = payload.get("befunde") + if not befunde: + return prompt + liste = "\n".join(f"- {b}" for b in befunde[:6]) + return (prompt + "\n\n## WICHTIG: Korrektur\n\nDein vorheriger Versuch scheiterte an " + "diesen Prüf-Befunden. Behebe GENAU diese Punkte (Zitate müssen wörtlich aus " + "der Quelle stammen — kopiere sie zeichengenau):\n" + liste + "\n") + + +async def _befunde_merken(flow: Flow, card: dict, fehler: list[str]) -> None: + card["payload"]["befunde"] = fehler[:6] + await db.kanban_set_payload(flow.topic, BOARD, card["card_id"], card["payload"]) + + +async def _proc_schneiden(ctx: ScanKontext, flow: Flow, cards: list[dict]) -> None: + async def verarbeite(c: dict) -> str: + p = c["payload"] + prompt = _mit_befunden( + _prompt("einheiten", DATEI=p["datei"], QUELLE=p["text"], + SYMBOLE="\n".join(f"- {s}" for s in p["symbole"]) or "- (keine)"), p) + out = await _llm(flow, "schneiden", c["card_id"], "schneiden", prompt, p["datei"]) + out, gestrichen = gates.repariere_kanten(out, ctx.wurzel, p["datei"], ctx.quelle_cache) + out, korrigiert = gates.repariere_belege(out, ctx.wurzel, p["datei"], ctx.quelle_cache) + fehler, warnungen, einheiten = gates.pruefe_fragment(out, ctx.wurzel, p["datei"], + ctx.quelle_cache) + if fehler: + await _befunde_merken(flow, c, fehler) + raise ValueError(f"Gates: {'; '.join(fehler[:3])}") + warnungen += [f"Kante gestrichen: {z}" for z in gestrichen] + warnungen += [f"Beleg geschnappt: {z}" for z in korrigiert] + _, zusatz, _ = gates.parse_einheiten(out) + fehlend = gates.fehlende_symbole(p["symbole"], einheiten, zusatz) + p["fragmente"] = [out] + p["fehlend"] = fehlend + p["warnungen"] = warnungen + p.pop("befunde", None) + await db.kanban_set_payload(flow.topic, BOARD, c["card_id"], p) + return "nachfass" if fehlend else "sammeln" + await _je_karte(flow, cards, verarbeite) + + +async def _proc_nachfass(ctx: ScanKontext, flow: Flow, cards: list[dict]) -> None: + async def verarbeite(c: dict) -> str: + p = c["payload"] + fehlend = p["fehlend"][:MAX_NACHFASS_SYMBOLE] + prompt = _mit_befunden( + _prompt("nachfass", DATEI=p["datei"], QUELLE=p["text"], + FEHLEND="\n".join(f"- {s}" for s in fehlend), + VORHANDEN="\n\n".join(p["fragmente"])), p) + out = await _llm(flow, "nachfass", c["card_id"], "nachfass", prompt, p["datei"]) + out, _ = gates.repariere_kanten(out, ctx.wurzel, p["datei"], ctx.quelle_cache) + out, _ = gates.repariere_belege(out, ctx.wurzel, p["datei"], ctx.quelle_cache) + fehler, _, _ = gates.pruefe_fragment(out, ctx.wurzel, p["datei"], ctx.quelle_cache) \ + if out.strip().startswith("## ") else ([], [], []) + if fehler: + await _befunde_merken(flow, c, fehler) + raise ValueError(f"Gates (Nachfass): {'; '.join(fehler[:3])}") + # Abdeckung über ALLE Fragmente des Chunks prüfen + gesamt = "\n\n".join(p["fragmente"] + [out]) + einheiten, zusatz, _ = gates.parse_einheiten(gesamt) + immer_noch = gates.fehlende_symbole(p["symbole"], einheiten, zusatz) + if immer_noch: + raise ValueError(f"Nachfass ließ Symbole offen: {', '.join(immer_noch[:5])}") + p["fragmente"].append(out) + p["fehlend"] = [] + p.pop("befunde", None) + await db.kanban_set_payload(flow.topic, BOARD, c["card_id"], p) + return "sammeln" + await _je_karte(flow, cards, verarbeite) + + +async def _proc_sammeln(ctx: ScanKontext, flow: Flow, cards: list[dict]) -> None: + """Drain: alle Chunk-Karten liegen vor. Fragmente je Quelldatei mergen, Staging + schreiben, Übersichten bauen, eine Karte je Sicht-Art anlegen.""" + je_datei: dict[str, list[dict]] = {} + for c in cards: + je_datei.setdefault(c["payload"]["datei"], []).append(c) + (ctx.lauf_dir / "einheiten").mkdir(parents=True, exist_ok=True) + ids: set[str] = set() + kurz_zeilen: list[str] = [] # ID + beschreibung (features) + kanten_zeilen: list[str] = [] # ID + beschreibung + kanten (architektur/flows) + for datei, karten in sorted(je_datei.items()): + karten.sort(key=lambda c: c["payload"]["start"]) + rumpf = artefakte.merge_fragmente([f for c in karten for f in c["payload"]["fragmente"]]) + text = artefakte.einheiten_datei(datei, rumpf, ctx.stand) + (ctx.lauf_dir / artefakte.datei_pfad(datei)).write_text(text, encoding="utf-8") + ids |= artefakte.alle_ids(text) + einheiten, _, _ = gates.parse_einheiten(text) + for e in einheiten: + kurz_zeilen.append(f"- {e['id']}: {e['felder'].get('beschreibung', '')}") + kanten = "; ".join(f"{typ} {ziel}" for _, typ, ziel in e["kanten"]) + kanten_zeilen.append(kurz_zeilen[-1] + (f"\n kanten: {kanten}" if kanten else "")) + for datei, text in ctx.bestand.items(): # Re-Scan: unveränderte Dateien zählen mit + ids |= artefakte.alle_ids(text) + einheiten, _, _ = gates.parse_einheiten(text) + for e in einheiten: + kurz_zeilen.append(f"- {e['id']}: {e['felder'].get('beschreibung', '')}") + kanten = "; ".join(f"{typ} {ziel}" for _, typ, ziel in e["kanten"]) + kanten_zeilen.append(kurz_zeilen[-1] + (f"\n kanten: {kanten}" if kanten else "")) + (ctx.lauf_dir / "uebersicht-kurz.md").write_text("\n".join(sorted(kurz_zeilen)), encoding="utf-8") + (ctx.lauf_dir / "uebersicht-kanten.md").write_text("\n".join(sorted(kanten_zeilen)), encoding="utf-8") + (ctx.lauf_dir / "ids.txt").write_text("\n".join(sorted(ids)), encoding="utf-8") + for art in SICHT_ARTEN: + await db.kanban_upsert_card(flow.topic, BOARD, f"sicht-{art}", "sicht", "sichten", + {"art": art}) + await db.kanban_advance_many(flow.topic, BOARD, + [(c["card_id"], "chunk-fertig") for c in cards]) + flow.wake.set() + + +async def _proc_sichten(ctx: ScanKontext, flow: Flow, cards: list[dict]) -> None: + ids = set((ctx.lauf_dir / "ids.txt").read_text(encoding="utf-8").splitlines()) + + async def verarbeite(c: dict) -> str: + art = c["payload"]["art"] + uebersicht = "uebersicht-kurz.md" if art == "features" else "uebersicht-kanten.md" + prompt = _mit_befunden( + _prompt(f"sichten-{art}", PROJEKT=flow.topic, + EINHEITEN=(ctx.lauf_dir / uebersicht).read_text(encoding="utf-8")), c["payload"]) + out = await _llm(flow, "sichten", c["card_id"], "sichten", prompt, art) + out, gestrichen = gates.repariere_referenzen(out, ids) + if gestrichen: + log.info("scan %s: %s — %d unbekannte Referenzen gestrichen", flow.topic, art, + len(gestrichen)) + fehler = gates.pruefe_referenzen(out, ids) + if fehler: + await _befunde_merken(flow, c, fehler) + raise ValueError(f"Referenzen ({art}): {'; '.join(fehler[:3])}") + (ctx.lauf_dir / f"sicht-{art}.md").write_text(out, encoding="utf-8") + return "schreiben" + await _je_karte(flow, cards, verarbeite) + + +async def _proc_schreiben(ctx: ScanKontext, flow: Flow, cards: list[dict]) -> None: + """Drain nach allen Sichten: .planer/ im Ziel-Repo schreiben.""" + dateien: dict[str, str] = {} + for p in (ctx.lauf_dir / "einheiten").glob("*.md"): + dateien[f"einheiten/{p.name}"] = p.read_text(encoding="utf-8") + for datei, text in ctx.bestand.items(): + dateien.setdefault(artefakte.datei_pfad(datei), text) + fehlend: list[str] = [] # gescheiterte Sichten: auslassen statt Kaskade (sichtbar degradieren) + if (ctx.lauf_dir / "sicht-features.md").is_file(): + features = (ctx.lauf_dir / "sicht-features.md").read_text(encoding="utf-8") + kern, _, bereiche = features.partition("# Bereich:") + dateien["kern.md"] = kern.strip() + "\n" + for i, block in enumerate(("# Bereich:" + bereiche).split("# Bereich:")): + if not block.strip(): + continue + name = block.splitlines()[0].strip().lower().replace(" ", "-").replace("/", "-") + dateien[f"features/{name or f'bereich-{i}'}.md"] = "# Bereich:" + block.rstrip() + "\n" + else: + fehlend.append("features") + for art, zieldatei in (("architektur", "architektur.md"), ("flows", "flows.md")): + if (ctx.lauf_dir / f"sicht-{art}.md").is_file(): + dateien[zieldatei] = (ctx.lauf_dir / f"sicht-{art}.md").read_text(encoding="utf-8") + else: + fehlend.append(art) + if fehlend: + flow.state["sichten_fehlend"] = fehlend + log.warning("scan %s: Sichten fehlen (Karten dead): %s", flow.topic, ", ".join(fehlend)) + if not (ctx.wurzel / ".planer" / "pruefung.md").is_file(): # nie Nutzer-Edits überschreiben + dateien["pruefung.md"] = artefakte.pruefung_geruest(ctx.wurzel, flow.topic) + artefakte.schreibe_planer(ctx.wurzel, dateien) + flow.state["geschrieben"] = sorted(dateien) + await db.kanban_advance_many(flow.topic, BOARD, [(c["card_id"], "fertig") for c in cards]) + flow.wake.set() + + +# --- Flow-Start ------------------------------------------------------------------------ + +def scan_stages(ctx: ScanKontext, flow: Flow) -> list[Stage]: + # gate=research_done an den Barriere-Stufen ist PFLICHT (Abnahme-Befund): die Barriere + # prüft nur die Upstream-Stufen — ohne Gate drained `sammeln`, während der Producer + # noch Karten einreiht, und die Sichten sehen eine Teil-Übersicht. + fertig_produziert = lambda: flow.research_done # noqa: E731 + return chain_stages([ + Stage(BOARD, "schneiden", lambda cs: _proc_schneiden(ctx, flow, cs)), + Stage(BOARD, "nachfass", lambda cs: _proc_nachfass(ctx, flow, cs)), + Stage(BOARD, "sammeln", lambda cs: _proc_sammeln(ctx, flow, cs), + barrier=True, drain=True, gate=fertig_produziert), + Stage(BOARD, "sichten", lambda cs: _proc_sichten(ctx, flow, cs)), + Stage(BOARD, "schreiben", lambda cs: _proc_schreiben(ctx, flow, cs), + barrier=True, drain=True, gate=fertig_produziert), + ]) + + +async def run_scan(wurzel: Path, projekt: str, stand: str, set_p=None, + nur_dateien: set[str] | None = None, + bestand: dict[str, str] | None = None, + fortsetzen: bool = False) -> dict: + """Scan eines Projekt-Repos. `nur_dateien` beschränkt auf geänderte Dateien (Re-Scan); + `bestand` = unveränderte Einheiten-Dateien {quelldatei: text}. `fortsetzen=True` + setzt einen abgebrochenen/fehlgeschlagenen Lauf fort: tote Chunks laufen neu durchs + LLM, fertige nur durchs mechanische Sammeln (Fragmente stecken im Payload) — setzt + unveränderten HEAD voraus. → {status, geschrieben, dead}.""" + run_id = f"scan-{time.time_ns()}" # eindeutig auch bei zwei Läufen in derselben Sekunde + lauf_dir = config.LAEUFE_DIR / projekt / run_id + lauf_dir.mkdir(parents=True, exist_ok=True) + ctx = ScanKontext(wurzel, stand, lauf_dir) + ctx.bestand = bestand or {} + flow = Flow(projekt) + db.set_current_run(projekt, run_id) + + async def producer(): + try: + if fortsetzen: + n_neu = n_fertig = 0 + for c in await db.kanban_cards(flow.topic, BOARD, kind="chunk"): + if c["stage"] == "dead": + await db.kanban_upsert_card(flow.topic, BOARD, c["card_id"], + "chunk", "schneiden", None) + n_neu += 1 + elif c["stage"] == "chunk-fertig": + await db.kanban_upsert_card(flow.topic, BOARD, c["card_id"], + "chunk", "sammeln", None) + n_fertig += 1 + log.info("scan %s: Fortsetzung — %d neu, %d nur sammeln", projekt, n_neu, n_fertig) + return + chunks = await asyncio.to_thread(chunker.chunks_fuer_repo, wurzel, nur_dateien) + for i, chunk in enumerate(chunks): + await db.kanban_upsert_card(flow.topic, BOARD, f"chunk-{i:04d}", "chunk", + "schneiden", chunk) + log.info("scan %s: %d Chunks angelegt", projekt, len(chunks)) + finally: + flow.done_producer() + + flow.add_producer() # SYNCHRON vor create_task (Quieszenz-Race) + try: + await run_flow(flow, scan_stages(ctx, flow), [producer()], set_p) + finally: + db.set_current_run(projekt, None) + dead = await db.kanban_dead(projekt) + status = "pausiert" if flow.state.get("infra_paused") else ("fehler" if dead else "ok") + return {"status": status, "infra_error": flow.state.get("infra_error", ""), + "geschrieben": flow.state.get("geschrieben", []), + "dead": [c["card_id"] for c in dead]} diff --git a/backend/scan_dienst.py b/backend/scan_dienst.py new file mode 100644 index 0000000..a615e41 --- /dev/null +++ b/backend/scan_dienst.py @@ -0,0 +1,147 @@ +"""Scan-Dienst: Vorflug-Checks, Re-Scan-Planung und Hintergrund-Läufe. + +Eine Wahrheit für CLI und Server: cli.py und routes.py delegieren beide hierher. +Doppelstart-Guard nach Creator-Muster: prozess-lokales Dict + idempotente Antwort + +Re-Entry-Check in der Coroutine (gilt nur im eigenen Prozess — bei laufendem Server +Scans über die UI starten, nicht parallel per CLI). +""" +import asyncio +import logging +import os +import time +from pathlib import Path + +import agents +import artefakte +import chunker +import config +import repo +import scan_board + +log = logging.getLogger("planer.dienst") + + +class VorflugFehler(Exception): + """Lauf darf nicht starten (kein Repo, dirty tree, Rolle/Provider unbrauchbar).""" + + +def vorflug(wurzel: Path) -> str: + """Checks vor jedem Lauf → HEAD-Hash. Wirft VorflugFehler (Erkenntnis 13: + lieber vorher stoppen als leer verbrennen).""" + if not wurzel.is_dir(): + raise VorflugFehler(f"{wurzel} ist kein Verzeichnis") + if not repo.ist_repo(wurzel): + raise VorflugFehler(f"{wurzel} ist kein git-Repo — Anker brauchen Commit-Hashes (git init && commit)") + if not repo.working_tree_sauber(wurzel): + raise VorflugFehler(f"{wurzel} hat uncommittete Änderungen — erst committen, dann scannen") + if not os.getenv("PLANER_FAKE_AGENTS"): + for rolle in config.ROLLEN: + try: + provider, _ = config.resolve_role(rolle) + except RuntimeError as e: + raise VorflugFehler(str(e)) from e + if not agents.provider_available(provider): + raise VorflugFehler(f"Provider '{provider}' (Rolle {rolle}) nicht nutzbar — CLI/Key prüfen") + return repo.head_hash(wurzel) + + +def einheiten_bestand(wurzel: Path) -> dict[str, tuple[str, str]]: + """{quelldatei: (stand, text)} aus den vorhandenen .planer/einheiten/-Dateien.""" + out: dict[str, tuple[str, str]] = {} + verzeichnis = wurzel / ".planer" / "einheiten" + for p in verzeichnis.glob("*.md") if verzeichnis.is_dir() else []: + text = p.read_text(encoding="utf-8") + kopf = text.splitlines()[0] if text else "" + datei = kopf.removeprefix("# Einheiten:").strip() + stand = artefakte.lese_stand(text) + if datei and stand: + out[datei] = (stand, text) + return out + + +def rescan_plan(wurzel: Path) -> tuple[set[str], dict[str, str], list[str]]: + """→ (zu_scannen, unveraendert {datei: text}, geloeschte_quelldateien). + Wirft VorflugFehler, wenn noch kein Scan existiert.""" + bestand = einheiten_bestand(wurzel) + if not bestand: + raise VorflugFehler("keine .planer/einheiten/ gefunden — erst `scan` ausführen") + scanbar = {str(p.relative_to(wurzel)) for p in chunker.dateien(wurzel)} + diff_cache: dict[str, set[str]] = {} + + def geaendert_seit(stand: str) -> set[str]: + if stand not in diff_cache: + diff_cache[stand] = repo.geaenderte_dateien(wurzel, stand)[0] + return diff_cache[stand] + + zu_scannen: set[str] = scanbar - set(bestand) + unveraendert: dict[str, str] = {} + for datei, (stand_alt, text) in bestand.items(): + if datei not in scanbar: + continue + if stand_alt == "UNBEKANNT" or datei in geaendert_seit(stand_alt): + zu_scannen.add(datei) + else: + unveraendert[datei] = text + geloescht = [datei for datei in bestand if datei not in scanbar] + return zu_scannen, unveraendert, geloescht + + +async def rescan_lauf(wurzel: Path, projekt: str, stand: str, set_p=None) -> dict: + """Kompletter Re-Scan: Plan, Aufräumen gelöschter Artefakte, Lauf. Keine Änderungen → + {status: 'unveraendert'}.""" + zu_scannen, unveraendert, geloescht = rescan_plan(wurzel) + for datei in geloescht: + (wurzel / ".planer" / artefakte.datei_pfad(datei)).unlink(missing_ok=True) + if not zu_scannen and not geloescht: + return {"status": "unveraendert", "geschrieben": [], "dead": []} + if not zu_scannen and unveraendert: + # Nur Löschungen: Sichten müssen neu — kleinste verbliebene Datei mit-rescannen + zu_scannen = {min(unveraendert, key=lambda d: len(unveraendert[d]))} + unveraendert.pop(next(iter(zu_scannen))) + log.info("rescan %s: %d neu, %d unverändert, %d gelöscht", + projekt, len(zu_scannen), len(unveraendert), len(geloescht)) + return await scan_board.run_scan(wurzel, projekt, stand, set_p=set_p, + nur_dateien=zu_scannen, bestand=unveraendert) + + +# --- Hintergrund-Läufe (Server) -------------------------------------------------------- + +_laeufe: dict[str, dict] = {} # projekt → {task, art, gestartet, ergebnis} + + +def starte(name: str, wurzel: Path, art: str, fortsetzen: bool = False) -> str: + """Startet scan|rescan als Hintergrund-Task. → 'gestartet' | 'laeuft'. + Wirft VorflugFehler synchron (Route antwortet 409 mit Meldung).""" + eintrag = _laeufe.get(name) + if eintrag and not eintrag["task"].done(): + return "laeuft" + stand = vorflug(wurzel) + if art == "rescan": + rescan_plan(wurzel) # wirft synchron, wenn es keinen Erst-Scan gibt + + async def lauf(): + if (e := _laeufe.get(name)) and e.get("laeuft_intern"): # Re-Entry-Schutz + return + _laeufe[name]["laeuft_intern"] = True + try: + if art == "rescan": + ergebnis = await rescan_lauf(wurzel, name, stand) + else: + ergebnis = await scan_board.run_scan(wurzel, name, stand, fortsetzen=fortsetzen) + _laeufe[name]["ergebnis"] = ergebnis + except Exception as e: # Status muss den Fehler zeigen, nie stiller Tod + log.exception("lauf %s (%s) abgebrochen", name, art) + _laeufe[name]["ergebnis"] = {"status": "abbruch", "infra_error": str(e), + "geschrieben": [], "dead": []} + + _laeufe[name] = {"task": asyncio.create_task(lauf()), "art": art, + "gestartet": time.time(), "ergebnis": None} + return "gestartet" + + +def status(name: str) -> dict | None: + eintrag = _laeufe.get(name) + if eintrag is None: + return None + return {"laeuft": not eintrag["task"].done(), "art": eintrag["art"], + "gestartet": eintrag["gestartet"], "ergebnis": eintrag["ergebnis"]} diff --git a/backend/server.py b/backend/server.py new file mode 100644 index 0000000..9f7d3ce --- /dev/null +++ b/backend/server.py @@ -0,0 +1,48 @@ +"""FastAPI-Server des Planers (Phase 2). + +Start: `uvicorn server:app --port 8100` aus backend/ — OHNE --reload: der Reload killt +laufende Scans im eigenen Prozess (Creator-Lehre; siehe README, Selbst-Änderungs-Regel). +""" +import sys +from contextlib import asynccontextmanager +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +from fastapi import FastAPI # noqa: E402 +from fastapi.staticfiles import StaticFiles # noqa: E402 +from starlette.responses import Response # noqa: E402 + +import agents # noqa: E402 +import config # noqa: E402 +import database as db # noqa: E402 +from routes import router # noqa: E402 + +FRONTEND_DIST = config.PROJECT_ROOT / "frontend" / "dist" + + +@asynccontextmanager +async def lifespan(app: FastAPI): + await db.init_db() + agents.on_event = db.add_event + yield + await db.close_db() + + +class CachedStatic(StaticFiles): + """assets/ = unveränderlich (gehashte Namen), index.html = nie cachen.""" + + def file_response(self, full_path, stat_result, scope, status_code=200) -> Response: + resp = super().file_response(full_path, stat_result, scope, status_code) + pfad = str(full_path) + if "/assets/" in pfad: + resp.headers["Cache-Control"] = "public, max-age=31536000, immutable" + elif pfad.endswith("index.html"): + resp.headers["Cache-Control"] = "no-cache" + return resp + + +app = FastAPI(title="Planer", lifespan=lifespan) +app.include_router(router) +if FRONTEND_DIST.exists(): + app.mount("/", CachedStatic(directory=FRONTEND_DIST, html=True), name="frontend") diff --git a/backend/templates/einheiten.md b/backend/templates/einheiten.md new file mode 100644 index 0000000..3b8da9d --- /dev/null +++ b/backend/templates/einheiten.md @@ -0,0 +1,53 @@ +# Auftrag: Code-Ausschnitt in Einheiten zerlegen + +Du bekommst unten einen Ausschnitt der Datei `` aus einem Software-Projekt. +Zerlege ihn in **Einheiten** und gib NUR die Einheiten-Abschnitte im unten definierten +Format zurück — nichts davor, nichts danach, keine Code-Fences um das Gesamtergebnis. + +Diese Top-Level-Symbole des Ausschnitts MÜSSEN alle abgedeckt sein: + + +## Was ist eine Einheit + +Das Kleinste mit **eigener Verantwortung**, das sich in einem Satz beschreiben lässt — +meist eine Funktion oder Klasse; mehrere kleine, zusammengehörige Symbole dürfen eine +Einheit bilden (Hauptsymbol als ID, weitere je als `anker:`-Zeile). Jedes gelistete +Symbol gehört zu genau einer Einheit (MECE). + +Hat der Ausschnitt KEINE def/class-Symbole (reines Skript, Konfiguration), erzeuge +GENAU EINE Datei-Einheit mit der ID `` (ohne `::`) — erfinde NIE Pseudo-Symbole. + +## Ausgabeformat (exakt einhalten) + +``` +## :: +beschreibung: +input: +output: +entscheidungen: +- + beleg: "" +kanten: +- ruft-auf: +- nutzt: +- wird-genutzt-von: +``` + +Regeln: +- `beschreibung:` genau EIN Satz, EINE Aufgabe. `input:`/`output:` sind Pflicht. +- 2–5 Entscheidungen je Einheit: Design-Entscheidungen und Garantien, KEIN + Implementierungs-Nacherzählen. Jede hat GENAU EINE `beleg:`-Zeile auf eigener Zeile. +- Der Beleg muss WÖRTLICH (Zeichen für Zeichen) im Ausschnitt vorkommen und ein + zusammenhängender Ausschnitt aus GENAU EINER Quellzeile sein — NIEMALS mehrere + Zeilen zu einer zusammenziehen. Max. ~60 Zeichen. +- Kanten-Typen nur: `ruft-auf`, `nutzt`, `wird-genutzt-von`, `löst-aus`, + `wird-ausgelöst-von`. Hinter dem Ziel steht NICHTS mehr. Ziele in anderen Modulen + (aus Imports ableitbar) als `pfad/zur/datei.py::symbol`. Keine Kante erfinden — + lieber weniger als falsche. +- Schreibe auf Deutsch. + +## Ausschnitt aus `` + +```python + +``` diff --git a/backend/templates/nachfass.md b/backend/templates/nachfass.md new file mode 100644 index 0000000..0e1de06 --- /dev/null +++ b/backend/templates/nachfass.md @@ -0,0 +1,33 @@ +# Auftrag: Fehlende Einheiten ergänzen + +Ein Ausschnitt der Datei `` wurde bereits in Einheiten zerlegt (Bestand unten). +Die Abdeckungsprüfung meldet, dass folgende Top-Level-Symbole noch KEINER Einheit +zugeordnet sind: + + + +Erzeuge NUR die fehlenden Einheiten-Abschnitte im selben Format wie der Bestand — +nichts davor, nichts danach, keine Wiederholung bestehender Einheiten, keine +Code-Fences um das Gesamtergebnis. + +NUR WENN ein fehlendes Symbol ein unselbstständiger Hilfssatellit einer bestehenden +Einheit ist — es wird AUSSCHLIESSLICH vom Hauptsymbol dieser Einheit verwendet und hat +keine eigene Verantwortung — darfst du statt einer neuen Einheit eine Zeile +`ergaenze-anker: :: zu ` ausgeben. +Im Zweifel IMMER eine eigene Einheit. Symbole mit benennbarer eigener Aufgabe +(Exception-Klasse, Schema-Bauer, Konstante mit Bedeutung) sind IMMER eigene Einheiten. + +Format-Regeln wie beim Erst-Scan: `beschreibung:` (ein Satz), `input:`, `output:`, +2–5 `entscheidungen:` mit je GENAU EINER `beleg:`-Zeile (WÖRTLICHES Zitat aus GENAU +EINER Quellzeile, max. ~60 Zeichen), `kanten:` nur mit den bekannten Typen. +Schreibe auf Deutsch. + +## Bestand (bereits zerlegte Einheiten dieses Ausschnitts) + + + +## Ausschnitt aus `` + +```python + +``` diff --git a/backend/templates/sichten-architektur.md b/backend/templates/sichten-architektur.md new file mode 100644 index 0000000..804a7e5 --- /dev/null +++ b/backend/templates/sichten-architektur.md @@ -0,0 +1,29 @@ +# Auftrag: Architektur-Sicht aggregieren + +Unten stehen alle Einheiten des Projekts `` (ID + Beschreibung + Kanten). +Aggregiere daraus die **Architektur-Sicht**: die Komponenten des Systems und ihre +Beziehungen. Beschreibe NUR, was Einheiten und Kanten belegen. + +## Ausgabeformat (exakt einhalten) + +``` +# Architektur: + +## Komponente: +beschreibung: +einheiten: , , … +beziehungen: +- nutzt: +- wird-genutzt-von: +``` + +Regeln: +- 3–8 Komponenten; jede Einheit gehört zu GENAU EINER Komponente (MECE). +- Eine Beziehung nur, wenn mindestens eine Kante zwischen Einheiten der beiden + Komponenten sie trägt — keine Beziehung erfinden. +- `einheiten:` nur IDs, die unten wirklich vorkommen (exakte Schreibweise). +- Schreibe auf Deutsch. Gib NUR das Markdown aus, ohne Code-Fences drumherum. + +## Einheiten von `` (mit Kanten) + + diff --git a/backend/templates/sichten-features.md b/backend/templates/sichten-features.md new file mode 100644 index 0000000..1c45f95 --- /dev/null +++ b/backend/templates/sichten-features.md @@ -0,0 +1,51 @@ +# Auftrag: Feature-Sicht und Kern aggregieren + +Unten stehen alle Einheiten des Projekts `` (ID + Ein-Satz-Beschreibung). +Aggregiere daraus die **Feature-Sicht** (was kann das Projekt aus Betreibersicht?) +und den **Kern** (was trägt das Projekt?). Beschreibe NUR, was die Einheiten belegen — +erfinde nichts aus Weltwissen. + +WICHTIG — Zielgruppe ist die GESCHÄFTSFÜHRUNG, nicht Entwickler: +- Beschreibe, WAS das Produkt kann und WOZU es gut ist — NIE, wie es im Code + umgesetzt ist. +- Verboten: Code-Begriffe und Jargon (Funktions-/Modul-/Dateinamen, Backticks, + Wörter wie Präfix, Spawn, Semaphore, CLI, Cache, Payload, Thread, Lock, Registry, + Callback, Endpoint). Wenn du so ein Wort brauchst, beschreibe stattdessen die + Wirkung in Alltagssprache. +- Titel und Sätze so, dass sie jemand ohne Programmierkenntnisse sofort versteht. + Beispiel: statt „Markiert einen Schlüssel-Präfix global als abgebrochen" → + „Laufende Arbeiten lassen sich gezielt stoppen". +- Die `einheiten:`-Referenzzeilen bleiben unverändert technisch (exakte IDs) — + sie sind Maschinen-Verweise, keine Leser-Texte. + +## Ausgabeformat (exakt einhalten; zuerst der Kern, dann die Bereiche) + +``` +# Kern: +<2-4 Sätze: wofür das Projekt existiert und was es im Kern tut> + +tragende-einheiten: , , … + +# Bereich: +beschreibung: + +## Feature: [kern|rand] +beschreibung: + +### +einheiten: , +``` + +Regeln: +- 3–10 Bereiche; MECE je Ebene: Bereiche zerlegen das Projekt, Features ihren Bereich, + Teilfeatures ihr Feature — vollständig, überschneidungsfrei. +- Braucht ein Titel „und", mach zwei Bereiche/Features daraus. +- `[kern]` = trägt das Projekt, `[rand]` = Komfort/Beiwerk. +- `einheiten:` listet NUR IDs, die unten wirklich vorkommen (exakte Schreibweise); + jedes Teilfeature hat mindestens eine. Jede Einheit sollte in mindestens einem + Teilfeature auftauchen; reine interne Helfer dürfen unreferenziert bleiben. +- Schreibe auf Deutsch. Gib NUR das Markdown aus, ohne Code-Fences drumherum. + +## Einheiten von `` + + diff --git a/backend/templates/sichten-flows.md b/backend/templates/sichten-flows.md new file mode 100644 index 0000000..8b70d40 --- /dev/null +++ b/backend/templates/sichten-flows.md @@ -0,0 +1,26 @@ +# Auftrag: Flow-Sicht aggregieren + +Unten stehen alle Einheiten des Projekts `` (ID + Beschreibung + Kanten). +Aggregiere daraus die **Flow-Sicht**: die wichtigsten Abläufe des Systems als +Schrittfolgen. Beschreibe NUR Abläufe, die die Einheiten und ihre Kanten belegen. + +## Ausgabeformat (exakt einhalten) + +``` +# Flows: + +## Flow: +1. — +2. — , +``` + +Regeln: +- 2–6 Flows, je 3–10 Schritte; nur die tragenden Abläufe, keine Randfälle. +- Jeder Schritt endet mit ` — ` und mindestens einer Einheiten-ID, die unten wirklich + vorkommt (exakte Schreibweise). +- Die Schrittfolge muss zu den Kanten passen (wer ruft wen) — nichts erfinden. +- Schreibe auf Deutsch. Gib NUR das Markdown aus, ohne Code-Fences drumherum. + +## Einheiten von `` (mit Kanten) + + diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py new file mode 100644 index 0000000..8a0bc3b --- /dev/null +++ b/backend/tests/conftest.py @@ -0,0 +1,66 @@ +import sys +from pathlib import Path + +import pytest + +sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) + +import config # noqa: E402 +import database # noqa: E402 +import fake_agents # noqa: E402 + + +@pytest.fixture +async def testdb(tmp_path, monkeypatch): + """Frische SQLite-Datei je Test; setzt die modul-globale Connection zurück.""" + monkeypatch.setattr(config, "DB_PATH", tmp_path / "test.db") + database._db = None + await database.init_db() + yield database + await database.close_db() + + +@pytest.fixture +async def gescanntes_repo(tmp_path, monkeypatch, testdb): + """mini_repo als echtes git-Repo mit echtem .planer/ (Fake-Scan, echter HEAD-Hash) — + Grundlage für Viewer-/Drift-/Routen-Tests.""" + import shutil + import subprocess + + import fake_agents + import kanban + import repo as repo_mod + import scan_board + + wurzel = tmp_path / "mini" + shutil.copytree(Path(__file__).parent / "fixtures" / "mini_repo", wurzel) + env = {"PATH": "/usr/bin:/bin", "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", + "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t", "HOME": str(wurzel)} + + def git(*args): + subprocess.run(["git", "-C", str(wurzel), *args], check=True, capture_output=True, env=env) + + git("init", "-b", "main") + git("add", "-A") + git("commit", "-m", "start") + welt = fake_agents.Welt() + fake_agents.set_welt(welt) + fake_agents.standard_antworten(welt) + monkeypatch.setenv("PLANER_FAKE_AGENTS", "1") + monkeypatch.setattr(kanban, "RETRY_BACKOFF", 0.05) + ergebnis = await scan_board.run_scan(wurzel, "mini", stand=repo_mod.head_hash(wurzel)) + assert ergebnis["status"] == "ok", ergebnis + git("add", "-A") + git("commit", "-m", "artefakte") + yield wurzel, git + fake_agents.set_welt(None) + + +@pytest.fixture +def fake_welt(monkeypatch): + """Frische Fake-Welt + PLANER_FAKE_AGENTS aktiv; Tests hängen Antworten/Störungen an.""" + welt = fake_agents.Welt() + fake_agents.set_welt(welt) + monkeypatch.setenv("PLANER_FAKE_AGENTS", "1") + yield welt + fake_agents.set_welt(None) diff --git a/backend/tests/fixtures/mini_repo/anzeige.py b/backend/tests/fixtures/mini_repo/anzeige.py new file mode 100644 index 0000000..e05bab3 --- /dev/null +++ b/backend/tests/fixtures/mini_repo/anzeige.py @@ -0,0 +1,7 @@ +"""Mini-Fixture: Ausgabe.""" +from rechner import addiere + + +def zeige(a, b): + """Formatiert die Summe.""" + return f"Ergebnis: {addiere(a, b)}" diff --git a/backend/tests/fixtures/mini_repo/rechner.py b/backend/tests/fixtures/mini_repo/rechner.py new file mode 100644 index 0000000..9094dea --- /dev/null +++ b/backend/tests/fixtures/mini_repo/rechner.py @@ -0,0 +1,23 @@ +"""Mini-Fixture: kleiner Rechner.""" + +BASIS = 10 + + +def addiere(a, b): + """Summe zweier Zahlen.""" + return a + b + + +def skaliere(wert): + """Skaliert mit der Modul-Basis.""" + return wert * BASIS + + +class Speicher: + """Merkt sich das letzte Ergebnis.""" + + def __init__(self): + self.letztes = None + + def merke(self, wert): + self.letztes = wert diff --git a/backend/tests/test_agents.py b/backend/tests/test_agents.py new file mode 100644 index 0000000..f093091 --- /dev/null +++ b/backend/tests/test_agents.py @@ -0,0 +1,50 @@ +"""Provider-Layer: Fake-Umschaltung, harter Stopp ohne Rollen-Config, kein Fallback.""" +import re +from pathlib import Path + +import pytest + +import agents + + +async def test_fake_umschaltung(fake_welt): + fake_welt.antwort_auf(r"-schneiden-", lambda prompt: "ANTWORT") + rc, out, err = await agents.run_agent("scan-x-schneiden-1", "egal", 5, role="schneiden") + assert (rc, out) == (0, "ANTWORT") + assert fake_welt.calls == ["scan-x-schneiden-1"] + + +async def test_stoerung_dann_fehler(fake_welt): + fake_welt.antwort_auf(r".", lambda prompt: "ok") + fake_welt.stoerungen.append({"muster": r"-schneiden-", "modus": "fehler", "mal": 1}) + rc1, _, err1 = await agents.run_agent("scan-x-schneiden-1", "egal", 5, role="schneiden") + rc2, out2, _ = await agents.run_agent("scan-x-schneiden-1", "egal", 5, role="schneiden") + assert (rc1, err1) == (1, "fake-stoerung") + assert (rc2, out2) == (0, "ok") + + +async def test_infra_stoerung_wirft(fake_welt): + fake_welt.stoerungen.append({"muster": r".", "modus": "infra", "mal": 1}) + with pytest.raises(agents.AgentInfraError): + await agents.run_agent("scan-x-schneiden-1", "egal", 5, role="schneiden") + + +async def test_unkonfigurierte_rolle_pausiert(monkeypatch): + """Ohne Fake-Modus und ohne ROLLE_-Env: AgentInfraError (Lauf pausiert), kein Default.""" + monkeypatch.delenv("PLANER_FAKE_AGENTS", raising=False) + monkeypatch.delenv("ROLLE_JUDGE", raising=False) + with pytest.raises(agents.AgentInfraError, match="kein Modell konfiguriert"): + await agents.run_agent("scan-x-judge-1", "egal", 5, role="judge") + + +def test_kein_fallback_codepfad(): + """Der Creator-Fallback (_available_cached / 'routed provider unavailable') darf + nicht mitportiert worden sein.""" + quelle = Path(agents.__file__).read_text(encoding="utf-8") + assert "_available_cached" not in quelle + assert not re.search(r"run_provider", quelle) + + +def test_prioritaet_der_stufen(): + assert agents._agent_priority("scan-p-sichten-1") < agents._agent_priority("scan-p-schneiden-9") + assert agents._agent_priority("irgendwas") == len(agents._STAGE_PRIORITY) diff --git a/backend/tests/test_artefakte.py b/backend/tests/test_artefakte.py new file mode 100644 index 0000000..47e35e1 --- /dev/null +++ b/backend/tests/test_artefakte.py @@ -0,0 +1,65 @@ +"""Artefakt-Schicht: Merge, ergaenze-anker, Writer, Prüfungs-Gerüst.""" +from pathlib import Path + +import artefakte + +FRAG_A = """## a.py::eins +beschreibung: Erste. +input: x +output: y + +## a.py::zwei +beschreibung: Zweite. +""" + +FRAG_NACHFASS = """ergaenze-anker: a.py::_helfer zu a.py::eins + +## a.py::drei +beschreibung: Dritte. +""" + + +def test_merge_mit_nachfass(): + rumpf = artefakte.merge_fragmente([FRAG_A, FRAG_NACHFASS]) + assert rumpf.index("## a.py::eins") < rumpf.index("## a.py::zwei") < rumpf.index("## a.py::drei") + assert "anker: a.py::_helfer" in rumpf.split("## a.py::zwei")[0] # im eins-Block + assert "ergaenze-anker" not in rumpf + + +def test_merge_dubletten_fallen_weg(): + rumpf = artefakte.merge_fragmente([FRAG_A, FRAG_A]) + assert rumpf.count("## a.py::eins") == 1 + + +def test_einheiten_datei_und_stand(): + text = artefakte.einheiten_datei("a.py", "## a.py::eins\nbeschreibung: X.", "abc123") + assert text.startswith("# Einheiten: a.py\nstand: abc123\n") + assert artefakte.lese_stand(text) == "abc123" + + +def test_alle_ids(): + text = "## a.py::eins\nanker: a.py::_helfer\n\n## a.py::zwei\n" + assert artefakte.alle_ids(text) == {"a.py::eins", "a.py::_helfer", "a.py::zwei"} + + +def test_datei_pfad(): + assert artefakte.datei_pfad("backend/kanban.py") == "einheiten/backend__kanban.py.md" + + +def test_schreibe_planer(tmp_path): + pfade = artefakte.schreibe_planer(tmp_path, {"kern.md": "# Kern\n", + "einheiten/a.py.md": "# Einheiten: a.py\n"}) + assert (tmp_path / ".planer" / "kern.md").read_text() == "# Kern\n" + assert len(pfade) == 2 + + +def test_pruefung_geruest_mit_makefile(tmp_path): + (tmp_path / "Makefile").write_text("test:\n\tpytest\ndev:\n\tuvicorn\n") + text = artefakte.pruefung_geruest(tmp_path, "demo") + assert "tests: make test" in text and "start: make dev" in text + assert "lint: (keins vorhanden)" in text + + +def test_pruefung_geruest_ohne_alles(tmp_path): + text = artefakte.pruefung_geruest(tmp_path, "demo") + assert "tests: (keins vorhanden)" in text diff --git a/backend/tests/test_chunker.py b/backend/tests/test_chunker.py new file mode 100644 index 0000000..2190bd6 --- /dev/null +++ b/backend/tests/test_chunker.py @@ -0,0 +1,57 @@ +"""Chunker: Ausschlussliste, Symbol-Schnitt, Chunk-Größen.""" +from pathlib import Path + +import chunker + +MINI = Path(__file__).parent / "fixtures" / "mini_repo" + + +def test_mini_repo_dateien(): + rel = [str(p.relative_to(MINI)) for p in chunker.dateien(MINI)] + assert rel == ["anzeige.py", "rechner.py"] + + +def test_ausschluss(tmp_path): + (tmp_path / "ok.py").write_text("X = 1\n") + (tmp_path / ".env").write_text("GEHEIM=1\n") + (tmp_path / ".env.local").write_text("GEHEIM=2\n") + (tmp_path / "node_modules").mkdir() + (tmp_path / "node_modules" / "paket.py").write_text("Y = 1\n") + (tmp_path / ".planer").mkdir() + (tmp_path / ".planer" / "alt.py").write_text("Z = 1\n") + rel = [str(p.relative_to(tmp_path)) for p in chunker.dateien(tmp_path)] + assert rel == ["ok.py"] + + +def test_schnitt_mini(): + text = (MINI / "rechner.py").read_text() + chunks = chunker.schneide("rechner.py", text) + assert len(chunks) == 1 # klein → ein Chunk + assert chunks[0]["symbole"] == ["addiere", "skaliere", "Speicher"] + assert chunks[0]["text"] == text.rstrip("\n") # Kopf (Docstring, BASIS) im ersten Chunk + + +def test_schnitt_grosse_datei(): + """Symbole à 60 Zeilen → Chunks bleiben um CHUNK_ZEILEN, Schnitt nie mitten im Symbol.""" + bloecke = [f"def f{i}():\n" + "".join(f" x{j} = {j}\n" for j in range(60)) for i in range(20)] + text = "\n".join(bloecke) + chunks = chunker.schneide("gross.py", text) + assert len(chunks) > 1 + assert all(c["groesse"] <= chunker.CHUNK_ZEILEN + 61 for c in chunks) + alle = [s for c in chunks for s in c["symbole"]] + assert alle == [f"f{i}" for i in range(20)] # jedes Symbol genau einmal, in Reihenfolge + for c in chunks: + assert c["text"].splitlines()[0].startswith(("def ", "\n", '"')) # Schnitt an Blockgrenze + + +def test_creator_smoke(): + """Read-only gegen das echte Creator-Backend: board_inventory.py (2344 Z.) wird zerlegt.""" + wurzel = Path("/home/arbeit/projects/creator") + chunks = [c for c in chunker.chunks_fuer_repo(wurzel, {"backend/board_inventory.py"})] + assert len(chunks) >= 6 + assert all(c["groesse"] <= 700 for c in chunks) # kein Riesen-Chunk + + +def test_top_level_symbole(): + text = (MINI / "rechner.py").read_text() + assert chunker.top_level_symbole(text) == {"BASIS", "addiere", "skaliere", "Speicher"} diff --git a/backend/tests/test_config_rollen.py b/backend/tests/test_config_rollen.py new file mode 100644 index 0000000..6d68ed5 --- /dev/null +++ b/backend/tests/test_config_rollen.py @@ -0,0 +1,31 @@ +"""Rollen-Auflösung: explizit konfiguriert oder harter Stopp — nie ein Default.""" +import pytest + +import config + + +def test_konfigurierte_rolle(monkeypatch): + monkeypatch.setenv("ROLLE_SCHNEIDEN", "minimax:minimax/MiniMax-M3") + assert config.resolve_role("schneiden") == ("minimax", "minimax/MiniMax-M3") + + +def test_unkonfigurierte_rolle_stoppt(monkeypatch): + monkeypatch.delenv("ROLLE_JUDGE", raising=False) + with pytest.raises(RuntimeError, match="kein Modell konfiguriert"): + config.resolve_role("judge") + + +def test_unbekannter_provider_stoppt(monkeypatch): + monkeypatch.setenv("ROLLE_SICHTEN", "openai:gpt-4") + with pytest.raises(RuntimeError, match="unbekannter Provider"): + config.resolve_role("sichten") + + +def test_fehlendes_modell_stoppt(monkeypatch): + monkeypatch.setenv("ROLLE_NACHFASS", "minimax") + with pytest.raises(RuntimeError, match="Modell fehlt"): + config.resolve_role("nachfass") + + +def test_alle_rollen_deklariert(): + assert set(config.ROLLEN) == {"schneiden", "nachfass", "sichten", "judge"} diff --git a/backend/tests/test_database.py b/backend/tests/test_database.py new file mode 100644 index 0000000..a5df504 --- /dev/null +++ b/backend/tests/test_database.py @@ -0,0 +1,33 @@ +"""DB-Roundtrip: Karten + Telemetrie.""" +import json + + +async def test_karten_roundtrip(testdb): + await testdb.kanban_upsert_card("p", "scan", "c1", "chunk", "schneiden", {"groesse": 10}) + await testdb.kanban_upsert_card("p", "scan", "c2", "chunk", "schneiden", {"groesse": 99}) + karten = await testdb.kanban_pull("p", "scan", "schneiden", 10) + assert [k["card_id"] for k in karten] == ["c2", "c1"] # LPT: größte zuerst + assert karten[0]["payload"]["groesse"] == 99 + + await testdb.kanban_advance_many("p", "scan", [("c1", "sammeln")]) + assert await testdb.kanban_count("p", "schneiden") == 1 + assert (await testdb.kanban_stage_counts("p"))["scan"] == {"schneiden": 1, "sammeln": 1} + + +async def test_payload_erhalt_bei_upsert_ohne_payload(testdb): + await testdb.kanban_upsert_card("p", "scan", "c1", "chunk", "schneiden", {"datei": "a.py"}) + await testdb.kanban_upsert_card("p", "scan", "c1", "chunk", "nachfass", None) + karte = await testdb.kanban_get_card("p", "scan", "c1") + assert karte["stage"] == "nachfass" and karte["payload"]["datei"] == "a.py" + + +async def test_events_mit_run_id(testdb): + testdb.set_current_run("p", "lauf-1") + await testdb.add_event("p", "agent", key="scan:c1", status="ok", dur_ms=1200, + meta={"tokens": {"output": 500}}) + db = await testdb.get_db() + cursor = await db.execute("SELECT kind, status, run_id, meta FROM events WHERE topic='p'") + kind, status, run_id, meta = await cursor.fetchone() + assert (kind, status, run_id) == ("agent", "ok", "lauf-1") + assert json.loads(meta)["tokens"]["output"] == 500 + testdb.set_current_run("p", None) diff --git a/backend/tests/test_gates.py b/backend/tests/test_gates.py new file mode 100644 index 0000000..be4a98e --- /dev/null +++ b/backend/tests/test_gates.py @@ -0,0 +1,159 @@ +"""Gates gegen das mini_repo-Fixture: gültiges Fragment passiert, jede Manipulation +wird mit genau dem erwarteten Fehler gefangen.""" +from pathlib import Path + +import gates + +MINI = Path(__file__).parent / "fixtures" / "mini_repo" + +GUT = '''# Einheiten: rechner.py +stand: UNBEKANNT + +## rechner.py::addiere +beschreibung: Addiert zwei Zahlen. +input: zwei Zahlen a, b +output: die Summe +entscheidungen: +- Reine Funktion ohne Zustand. + beleg: "return a + b" +kanten: +- wird-genutzt-von: anzeige.py::zeige + +## rechner.py::Speicher +beschreibung: Merkt sich das letzte Ergebnis. +input: Werte über merke() +output: letzter Wert in self.letztes +entscheidungen: +- Startet leer. + beleg: "self.letztes = None" +kanten: +- nutzt: rechner.py::addiere +''' + + +def test_gutes_fragment_passiert(): + fehler, warnungen, einheiten = gates.pruefe_fragment(GUT, MINI, "rechner.py") + assert fehler == [] + assert [e["id"] for e in einheiten] == ["rechner.py::addiere", "rechner.py::Speicher"] + + +def test_falsches_zitat(): + kaputt = GUT.replace('beleg: "return a + b"', 'beleg: "return a - b"') + fehler, _, _ = gates.pruefe_fragment(kaputt, MINI, "rechner.py") + assert any("Zitat nicht wörtlich" in f for f in fehler) + + +def test_erfundener_anker(): + kaputt = GUT.replace("## rechner.py::addiere", "## rechner.py::subtrahiere") + fehler, _, _ = gates.pruefe_fragment(kaputt, MINI, "rechner.py") + assert any("Symbol 'subtrahiere' nicht in" in f for f in fehler) + + +def test_kaputte_kante(): + kaputt = GUT.replace("- nutzt: rechner.py::addiere", + "- nutzt: rechner.py::addiere (wichtig!)") + fehler, _, _ = gates.pruefe_fragment(kaputt, MINI, "rechner.py") + assert any("Kante unlesbar" in f for f in fehler) + + +def test_unbekannter_kanten_typ(): + kaputt = GUT.replace("- nutzt:", "- verwendet:") + fehler, _, _ = gates.pruefe_fragment(kaputt, MINI, "rechner.py") + assert any("unbekannter Kanten-Typ" in f for f in fehler) + + +def test_fremde_datei_abgelehnt(): + fehler, _, _ = gates.pruefe_fragment(GUT, MINI, "anzeige.py") + assert any("gehört nicht zur gescannten Datei" in f for f in fehler) + + +def test_leere_antwort(): + fehler, _, _ = gates.pruefe_fragment("", MINI, "rechner.py") + assert any("keine Einheit geparst" in f for f in fehler) + + +def test_escaping_normalisierung(): + frag = GUT.replace('beleg: "return a + b"', 'beleg: "return f\\"Ergebnis: {addiere(a, b)}\\""') + frag = frag.replace("## rechner.py::addiere", "## anzeige.py::zeige").replace( + "# Einheiten: rechner.py", "# Einheiten: anzeige.py") + # nur den umgebauten zeige-Block prüfen + block = frag.split("\n\n")[1] + fehler, _, _ = gates.pruefe_fragment(block, MINI, "anzeige.py") + assert not any("Zitat" in f for f in fehler) + + +def test_fehlende_symbole(): + _, _, einheiten = gates.pruefe_fragment(GUT, MINI, "rechner.py") + fehlt = gates.fehlende_symbole(["addiere", "skaliere", "Speicher", "BASIS"], einheiten, []) + assert fehlt == ["skaliere", "BASIS"] + fehlt2 = gates.fehlende_symbole(["skaliere"], einheiten, ["rechner.py::skaliere"]) + assert fehlt2 == [] + + +def test_repariere_kanten(): + """Erfundene Kanten-Ziele werden gestrichen (Datei erfunden, Symbol erfunden, + Prefix fehlt) — gültige Kanten und alle anderen Zeilen bleiben unangetastet.""" + kaputt = GUT.replace( + "- nutzt: rechner.py::addiere", + "- nutzt: rechner.py::addiere\n- ruft-auf: erfunden.py::x\n" + "- nutzt: rechner.py::gibtsnicht\n- löst-aus: nur_symbol") + bereinigt, gestrichen = gates.repariere_kanten(kaputt, MINI, "rechner.py") + assert len(gestrichen) == 3 + assert "- nutzt: rechner.py::addiere" in bereinigt + assert "erfunden.py" not in bereinigt and "gibtsnicht" not in bereinigt + fehler, _, _ = gates.pruefe_fragment(bereinigt, MINI, "rechner.py") + assert fehler == [] + + +def test_repariere_belege_schnappt_fast_richtige_zitate(): + """Ein-Zeichen-Abweichung (`=` statt Original) wird auf die echte Quellzeile + geschnappt; frei erfundene Zitate bleiben stehen und fallen im Gate durch.""" + kaputt = GUT.replace('beleg: "return a + b"', 'beleg: "return a+b"') + repariert, korrigiert = gates.repariere_belege(kaputt, MINI, "rechner.py") + assert len(korrigiert) == 1 + fehler, _, _ = gates.pruefe_fragment(repariert, MINI, "rechner.py") + assert fehler == [] + + erfunden = GUT.replace('beleg: "return a + b"', 'beleg: "raise TotalErfunden(xyz)"') + repariert2, korrigiert2 = gates.repariere_belege(erfunden, MINI, "rechner.py") + assert korrigiert2 == [] + fehler2, _, _ = gates.pruefe_fragment(repariert2, MINI, "rechner.py") + assert any("Zitat nicht wörtlich" in f for f in fehler2) + + +def test_qualifizierte_methode_als_symbol(): + frag = GUT.replace("## rechner.py::Speicher", "## rechner.py::Speicher.merke") + fehler, _, _ = gates.pruefe_fragment(frag, MINI, "rechner.py") + assert not any("Speicher.merke" in f for f in fehler) + + +def test_beleg_mit_anfuehrungszeichen(): + """Belege mit eingebetteten Quotes/Regex (Befund 17) parsen und passieren.""" + frag = ('## anzeige.py::zeige\nbeschreibung: Formatiert.\ninput: a, b\noutput: Text\n' + 'entscheidungen:\n- Nutzt einen f-String.\n' + ' beleg: "return f"Ergebnis: {addiere(a, b)}""\nkanten:\n') + fehler, _, _ = gates.pruefe_fragment(frag, MINI, "anzeige.py") + assert fehler == [] + + +def test_datei_einheit_ohne_symbole(tmp_path): + """Skript ohne def/class: Datei-Einheit `## pfad` (Befund 18).""" + (tmp_path / "skript.py").write_text('import sys\nprint(sys.argv)\n') + frag = ('## skript.py\nbeschreibung: Gibt Argumente aus.\ninput: argv\noutput: stdout\n' + 'entscheidungen:\n- Direkter Druck ohne Formatierung.\n beleg: "print(sys.argv)"\nkanten:\n') + fehler, _, einheiten = gates.pruefe_fragment(frag, tmp_path, "skript.py") + assert fehler == [] and einheiten[0]["id"] == "skript.py" + + +def test_referenz_korrektur_falscher_prefix(): + """Symbol existiert eindeutig unter anderer Datei → ID wird korrigiert (Befund 19).""" + sicht = "### Kann reparieren\neinheiten: falsch.py::_fix, kaputt.py::gibtsnirgends\n" + text, gestrichen = gates.repariere_referenzen(sicht, {"richtig.py::_fix", "a.py::x"}) + assert "richtig.py::_fix" in text + assert gestrichen == ["kaputt.py::gibtsnirgends"] + + +def test_referenz_integritaet(): + sicht = "### Kann rechnen\neinheiten: rechner.py::addiere, rechner.py::gibtsnicht\n" + fehler = gates.pruefe_referenzen(sicht, {"rechner.py::addiere"}) + assert fehler == ["unbekannte Einheiten-Referenz: rechner.py::gibtsnicht"] diff --git a/backend/tests/test_kanban.py b/backend/tests/test_kanban.py new file mode 100644 index 0000000..6e12636 --- /dev/null +++ b/backend/tests/test_kanban.py @@ -0,0 +1,128 @@ +"""Engine tests with fake processors (no LLM): flow, barrier, retry/dead-letter, producer race.""" + +import asyncio + +import pytest + +import kanban +from kanban import Flow, Stage, chain_stages, run_flow + +TOPIC = "t" +BOARD = "inventory" + + +def _advance_proc(db, to_stage): + async def proc(cards): + await db.kanban_advance_many(TOPIC, BOARD, [(c["card_id"], to_stage) for c in cards]) + return proc + + +async def _seed(db, n, stage="s1"): + for i in range(n): + await db.kanban_upsert_card(TOPIC, BOARD, f"card-{i}", "title", stage, {"title": f"T{i}"}) + + +async def test_cards_flow_through_stages(testdb): + db = testdb + await _seed(db, 7) + flow = Flow(TOPIC) + stages = chain_stages([ + Stage(BOARD, "s1", _advance_proc(db, "s2")), + Stage(BOARD, "s2", _advance_proc(db, "done")), + ]) + await asyncio.wait_for(run_flow(flow, stages), timeout=10) + assert await db.kanban_count(TOPIC, "done", board=BOARD) == 7 + assert await db.kanban_count(TOPIC, ["s1", "s2"], board=BOARD) == 0 + + +async def test_barrier_waits_for_upstream(testdb): + db = testdb + await _seed(db, 6) + upstream_left: list[int] = [] + + async def slow_s1(cards): + await asyncio.sleep(0.05) # keep upstream busy so an eager barrier would see queued cards + await db.kanban_advance_many(TOPIC, BOARD, [(c["card_id"], "gate") for c in cards]) + + async def barrier_proc(cards): + upstream_left.append(await db.kanban_count(TOPIC, ["s1"], board=BOARD)) + await db.kanban_advance_many(TOPIC, BOARD, [(c["card_id"], "done") for c in cards]) + + flow = Flow(TOPIC) + stages = chain_stages([ + Stage(BOARD, "s1", slow_s1), + Stage(BOARD, "gate", barrier_proc, barrier=True), + ]) + await asyncio.wait_for(run_flow(flow, stages), timeout=10) + assert await db.kanban_count(TOPIC, "done", board=BOARD) == 6 + assert upstream_left and all(n == 0 for n in upstream_left) # barrier never ran with s1 queued + + +async def test_retry_backoff_then_dead(testdb, monkeypatch): + db = testdb + monkeypatch.setattr(kanban, "RETRY_BACKOFF", 0.02) + await _seed(db, 1) + attempts = [] + + async def failing(cards): + attempts.append(cards[0]["retries"]) + raise RuntimeError("kaputt") + + flow = Flow(TOPIC) + stages = chain_stages([Stage(BOARD, "s1", failing)]) + await asyncio.wait_for(run_flow(flow, stages), timeout=10) + card = await db.kanban_get_card(TOPIC, BOARD, "card-0") + assert card["stage"] == "dead" + assert card["retries"] == kanban.MAX_CARD_RETRIES + assert "kaputt" in card["last_error"] + assert attempts == [0, 1, 2] # backoff between attempts, then dead-letter + + +async def test_requeue_dead(testdb): + db = testdb + await db.kanban_upsert_card(TOPIC, BOARD, "card-0", "title", "s1") + for _ in range(kanban.MAX_CARD_RETRIES): + await db.kanban_fail_card(TOPIC, BOARD, "card-0", "x", kanban.MAX_CARD_RETRIES, 0.0) + assert (await db.kanban_get_card(TOPIC, BOARD, "card-0"))["stage"] == "dead" + assert await db.kanban_requeue_dead(TOPIC, BOARD, "s1") == 1 + card = await db.kanban_get_card(TOPIC, BOARD, "card-0") + assert card["stage"] == "s1" and card["retries"] == 0 + + +async def test_producer_attach_in_idle_lull(testdb): + """Fix-6 regression: a producer attached while workers sit in the exit grace poll + must keep the flow alive and its cards must still be processed.""" + db = testdb + flow = Flow(TOPIC) + stages = chain_stages([Stage(BOARD, "s1", _advance_proc(db, "done"))]) + + async def producer_a(): + await db.kanban_upsert_card(TOPIC, BOARD, "card-a", "title", "s1") + flow.wake.set() + flow.done_producer() + + async def attacher(): + while await db.kanban_count(TOPIC, "done", board=BOARD) == 0: # wait for card-a done + await asyncio.sleep(0.01) + flow.add_producer() # synchronous BEFORE the work — the grace poll must see it + + async def producer_b(): + await db.kanban_upsert_card(TOPIC, BOARD, "card-b", "title", "s1") + flow.wake.set() + flow.done_producer() + await producer_b() + + flow.add_producer() # producer_a, counted before run_flow (sync add) + asyncio.get_event_loop().create_task(attacher()) + await asyncio.wait_for(run_flow(flow, stages, producers=[producer_a()]), timeout=10) + assert await db.kanban_count(TOPIC, "done", board=BOARD) == 2 + + +async def test_backoff_delays_pull(testdb, monkeypatch): + db = testdb + await db.kanban_upsert_card(TOPIC, BOARD, "card-0", "title", "s1") + await db.kanban_fail_card(TOPIC, BOARD, "card-0", "x", 5, 0.2) + assert await db.kanban_pull(TOPIC, BOARD, "s1", 10) == [] # in backoff → not pullable + assert await db.kanban_count(TOPIC, "s1", board=BOARD) == 1 # but still counts as queued + await asyncio.sleep(0.25) + assert len(await db.kanban_pull(TOPIC, BOARD, "s1", 10)) == 1 diff --git a/backend/tests/test_modell_ids.py b/backend/tests/test_modell_ids.py new file mode 100644 index 0000000..7660f54 --- /dev/null +++ b/backend/tests/test_modell_ids.py @@ -0,0 +1,32 @@ +"""Wächter für Leitprinzip 2: Modell-IDs stehen NUR in der .env, nie im Code. + +Greppt den gesamten backend-Quellcode (ohne tests/) nach Modell-ID-Mustern. +Schlägt dieser Test an, hat jemand ein Modell hart verdrahtet. +""" +import re +from pathlib import Path + +BACKEND = Path(__file__).resolve().parent.parent +MUSTER = re.compile(r"claude-\w+-\d|MiniMax-M\d|\bopus\b|\bsonnet\b|\bhaiku\b|gpt-\d", + re.IGNORECASE) + + +def test_keine_modell_ids_im_code(): + treffer = [] + for pfad in BACKEND.rglob("*.py"): + if "tests" in pfad.parts: + continue + for nr, zeile in enumerate(pfad.read_text(encoding="utf-8").splitlines(), 1): + if MUSTER.search(zeile): + treffer.append(f"{pfad.relative_to(BACKEND)}:{nr}: {zeile.strip()}") + assert not treffer, "Modell-IDs im Code gefunden (gehören in die .env):\n" + "\n".join(treffer) + + +def test_keine_modell_ids_in_templates(): + templates = BACKEND / "templates" + if not templates.is_dir(): + return + treffer = [f"{p.name}:{nr}" for p in templates.rglob("*.md") + for nr, zeile in enumerate(p.read_text(encoding="utf-8").splitlines(), 1) + if MUSTER.search(zeile)] + assert not treffer, f"Modell-IDs in Templates: {treffer}" diff --git a/backend/tests/test_rescan.py b/backend/tests/test_rescan.py new file mode 100644 index 0000000..a29245c --- /dev/null +++ b/backend/tests/test_rescan.py @@ -0,0 +1,102 @@ +"""Re-Scan über git-Diff: nur berührte Dateien werden neu gescannt, Löschungen räumen +auf, sauberer Tree ist Pflicht. Läuft komplett in der Fake-Welt.""" +import shutil +import subprocess +from pathlib import Path + +import pytest + +import fake_agents +import kanban +import repo as repo_mod + +MINI = Path(__file__).parent / "fixtures" / "mini_repo" + + +def _git(wurzel, *args): + subprocess.run(["git", "-C", str(wurzel), *args], check=True, capture_output=True, + env={"PATH": "/usr/bin:/bin", "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", + "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t", + "HOME": str(wurzel)}) + + +def _repo(tmp_path: Path) -> Path: + ziel = tmp_path / "repo" + shutil.copytree(MINI, ziel) + _git(ziel, "init", "-b", "main") + _git(ziel, "add", "-A") + _git(ziel, "commit", "-m", "start") + return ziel + + +@pytest.fixture +def cli(monkeypatch): + import cli as cli_mod + monkeypatch.setattr(kanban, "RETRY_BACKOFF", 0.05) + return cli_mod + + +async def test_scan_dann_rescan_nur_geaenderte(cli, fake_welt, testdb, tmp_path): + fake_agents.standard_antworten(fake_welt) + wurzel = _repo(tmp_path) + assert await cli._scan(wurzel) == 0 + stand1 = repo_mod.head_hash(wurzel) + assert f"stand: {stand1}" in (wurzel / ".planer" / "einheiten" / "rechner.py.md").read_text() + + _git(wurzel, "add", "-A") + _git(wurzel, "commit", "-m", "scan-artefakte") + (wurzel / "rechner.py").write_text((wurzel / "rechner.py").read_text() + "\n\ndef neu():\n return 1\n") + _git(wurzel, "add", "-A") + _git(wurzel, "commit", "-m", "neue funktion") + stand2 = repo_mod.head_hash(wurzel) + + fake_welt.calls.clear() + assert await cli._rescan(wurzel) == 0 + # Nur rechner.py wurde neu gescannt … + assert all("anzeige" not in k for k in fake_welt.calls if "-schneiden-" in k) + rechner = (wurzel / ".planer" / "einheiten" / "rechner.py.md").read_text() + anzeige = (wurzel / ".planer" / "einheiten" / "anzeige.py.md").read_text() + assert f"stand: {stand2}" in rechner and "## rechner.py::neu" in rechner + assert f"stand: {stand1}" in anzeige # unverändert übernommen + # … aber die Sichten wurden neu aggregiert und referenzieren auch den Bestand + assert any("-sichten-" in k for k in fake_welt.calls) + kern = (wurzel / ".planer" / "kern.md").read_text() + assert kern.startswith("# Kern:") + + +async def test_rescan_ohne_aenderung_ruft_kein_llm(cli, fake_welt, testdb, tmp_path): + fake_agents.standard_antworten(fake_welt) + wurzel = _repo(tmp_path) + assert await cli._scan(wurzel) == 0 + _git(wurzel, "add", "-A") + _git(wurzel, "commit", "-m", "scan-artefakte") + fake_welt.calls.clear() + assert await cli._rescan(wurzel) == 0 + assert fake_welt.calls == [] + + +async def test_rescan_geloeschte_datei_raeumt_auf(cli, fake_welt, testdb, tmp_path): + fake_agents.standard_antworten(fake_welt) + wurzel = _repo(tmp_path) + assert await cli._scan(wurzel) == 0 + _git(wurzel, "add", "-A") + _git(wurzel, "commit", "-m", "scan-artefakte") + (wurzel / "anzeige.py").unlink() + _git(wurzel, "add", "-A") + _git(wurzel, "commit", "-m", "anzeige weg") + assert await cli._rescan(wurzel) == 0 + assert not (wurzel / ".planer" / "einheiten" / "anzeige.py.md").exists() + + +async def test_unsauberer_tree_bricht_ab(cli, fake_welt, testdb, tmp_path): + wurzel = _repo(tmp_path) + (wurzel / "schmutz.py").write_text("X = 1\n") + with pytest.raises(SystemExit): + await cli._scan(wurzel) + + +async def test_kein_git_repo_bricht_ab(cli, fake_welt, testdb, tmp_path): + kein_repo = tmp_path / "kein-repo" + kein_repo.mkdir() + with pytest.raises(SystemExit): + await cli._scan(kein_repo) diff --git a/backend/tests/test_routes.py b/backend/tests/test_routes.py new file mode 100644 index 0000000..1e97a1e --- /dev/null +++ b/backend/tests/test_routes.py @@ -0,0 +1,87 @@ +"""API-Routen: Lesen + Scan-Start über httpx/ASGITransport (gleicher Event-Loop wie +create_task und der DB-Write-Lock — fastapi.TestClient wäre die Loop-Falle).""" +import asyncio + +import httpx +import pytest + +import config +import scan_dienst + + +@pytest.fixture +async def client(gescanntes_repo, monkeypatch, tmp_path): + wurzel, git = gescanntes_repo + datei = tmp_path / "projekte.txt" + datei.write_text(f"{wurzel}\n{tmp_path}/tot\n") + monkeypatch.setattr(config, "PROJEKTE_DATEI", datei) + scan_dienst._laeufe.clear() + from server import app + transport = httpx.ASGITransport(app=app) + async with httpx.AsyncClient(transport=transport, base_url="http://test") as c: + yield c, wurzel, git + + +async def test_projektliste(client): + c, wurzel, _ = client + r = await c.get("/api/projekte") + assert r.status_code == 200 + eintraege = {p["name"]: p for p in r.json()} + assert eintraege["mini"]["hat_planer"] is True + assert eintraege["mini"]["drift"] == [] + assert eintraege["mini"]["scan_laeuft"] is False + assert "fehler" in eintraege["tot"] + + +async def test_projekt_detail(client): + c, _, _ = client + r = await c.get("/api/projekte/mini") + daten = r.json() + assert daten["kern"]["titel"] == "mini" + assert daten["bereiche"] and daten["bereiche"][0]["features"] + assert "rechner.py::addiere" in daten["einheiten"] + assert daten["doku_ordnung"] + assert (await c.get("/api/projekte/gibtsnicht")).status_code == 404 + + +async def test_einheit_mit_code(client): + c, _, _ = client + r = await c.get("/api/projekte/mini/einheit", params={"id": "rechner.py::addiere"}) + e = r.json() + assert "return a + b" in e["code"] + assert e["veraltet"] is False + assert (await c.get("/api/projekte/mini/einheit", params={"id": "x.py::y"})).status_code == 404 + + +async def test_drift_nach_commit(client): + c, wurzel, git = client + (wurzel / "rechner.py").write_text((wurzel / "rechner.py").read_text() + "\nX9 = 9\n") + git("add", "-A") + git("commit", "-m", "drift") + r = await c.get("/api/projekte") + mini = next(p for p in r.json() if p["name"] == "mini") + assert mini["drift"] == ["rechner.py"] + e = (await c.get("/api/projekte/mini/einheit", params={"id": "rechner.py::addiere"})).json() + assert e["veraltet"] is True + + +async def test_scan_starten_und_pollen(client): + c, _, _ = client + r = await c.post("/api/projekte/mini/scan", json={"art": "rescan"}) + assert r.json()["status"] == "gestartet" + doppel = await c.post("/api/projekte/mini/scan", json={"art": "rescan"}) + assert doppel.json()["status"] in ("laeuft", "gestartet") # idempotent, nie Doppellauf + for _ in range(100): + s = (await c.get("/api/projekte/mini/scan-status")).json() + if not s["laeuft"]: + break + await asyncio.sleep(0.1) + assert s["ergebnis"]["status"] in ("ok", "unveraendert") + + +async def test_scan_409_bei_dirty_tree(client): + c, wurzel, _ = client + (wurzel / "schmutz.py").write_text("X = 1\n") + r = await c.post("/api/projekte/mini/scan", json={"art": "scan"}) + assert r.status_code == 409 + assert "uncommittete" in r.json()["detail"] diff --git a/backend/tests/test_scan_fake.py b/backend/tests/test_scan_fake.py new file mode 100644 index 0000000..ffd9f9a --- /dev/null +++ b/backend/tests/test_scan_fake.py @@ -0,0 +1,119 @@ +"""Fake-E2E: kompletter Scan-Lauf (Chunker → Board → .planer/) in Sekunden, ohne LLM. +Die Fake-Antworten durchlaufen die ECHTEN Gates — getestet wird der volle Pfad +inkl. Nachfass, Retry, Dead-Letter und Infra-Pause.""" +import asyncio +import shutil +from pathlib import Path + +import fake_agents +import kanban +import scan_board + +MINI = Path(__file__).parent / "fixtures" / "mini_repo" + + +def _repo(tmp_path: Path) -> Path: + ziel = tmp_path / "repo" + shutil.copytree(MINI, ziel) + return ziel + + +async def _scan(repo: Path, monkeypatch) -> dict: + monkeypatch.setattr(kanban, "RETRY_BACKOFF", 0.05) + return await asyncio.wait_for( + scan_board.run_scan(repo, "mini", stand="deadbeef"), timeout=30) + + +async def test_e2e_voller_scan(fake_welt, testdb, tmp_path, monkeypatch): + fake_agents.standard_antworten(fake_welt) + repo = _repo(tmp_path) + ergebnis = await _scan(repo, monkeypatch) + assert ergebnis["status"] == "ok", ergebnis + planer = repo / ".planer" + assert (planer / "einheiten" / "rechner.py.md").is_file() + assert (planer / "einheiten" / "anzeige.py.md").is_file() + assert (planer / "kern.md").read_text().startswith("# Kern: mini") + assert (planer / "architektur.md").is_file() + assert (planer / "flows.md").is_file() + assert (planer / "pruefung.md").is_file() + assert list((planer / "features").glob("*.md")) + einheiten = (planer / "einheiten" / "rechner.py.md").read_text() + assert "stand: deadbeef" in einheiten + assert "## rechner.py::addiere" in einheiten and "## rechner.py::Speicher" in einheiten + + +async def test_e2e_nachfass_pfad(fake_welt, testdb, tmp_path, monkeypatch): + """Erst-Scan lässt `skaliere` aus → Abdeckungs-Gate schickt den Chunk in den Nachfass.""" + fake_agents.standard_antworten(fake_welt, lasse_aus={"skaliere"}) + repo = _repo(tmp_path) + ergebnis = await _scan(repo, monkeypatch) + assert ergebnis["status"] == "ok", ergebnis + assert any("-nachfass-" in k for k in fake_welt.calls) + assert "## rechner.py::skaliere" in (repo / ".planer" / "einheiten" / "rechner.py.md").read_text() + + +async def test_e2e_stoerung_retry(fake_welt, testdb, tmp_path, monkeypatch): + """Einmal Garbage → Gates lehnen ab → Engine-Backoff → zweiter Versuch gelingt.""" + fake_agents.standard_antworten(fake_welt) + fake_welt.stoerungen.append({"muster": r"-schneiden-chunk-0000", "modus": "garbage", "mal": 1}) + repo = _repo(tmp_path) + ergebnis = await _scan(repo, monkeypatch) + assert ergebnis["status"] == "ok", ergebnis + + +async def test_e2e_dauerfehler_dead(fake_welt, testdb, tmp_path, monkeypatch): + """Dauerhafter Fehler auf einem Chunk → Karte landet im Dead-Letter, Lauf endet.""" + fake_agents.standard_antworten(fake_welt) + fake_welt.stoerungen.append({"muster": r"-schneiden-chunk-0000", "modus": "fehler", "mal": 99}) + repo = _repo(tmp_path) + ergebnis = await _scan(repo, monkeypatch) + assert ergebnis["status"] == "fehler" + assert ergebnis["dead"] == ["chunk-0000"] + + +async def test_e2e_infra_pause(fake_welt, testdb, tmp_path, monkeypatch): + """AgentInfraError → Lauf pausiert sofort (kein Dead-Letter, kein Raten).""" + fake_agents.standard_antworten(fake_welt) + fake_welt.stoerungen.append({"muster": r"-schneiden-", "modus": "infra", "mal": 1}) + repo = _repo(tmp_path) + ergebnis = await _scan(repo, monkeypatch) + assert ergebnis["status"] == "pausiert" + assert "fake-infra" in ergebnis["infra_error"] + + +async def test_e2e_fortsetzen_eine_sichten_runde(fake_welt, testdb, tmp_path, monkeypatch): + """Fortsetzung mit Mix aus toten und fertigen Chunks: die Sammeln-Barriere darf erst + öffnen, wenn der Producer ALLE Karten requeued hat — genau eine Sichten-Runde, und + die Sichten sehen die volle Übersicht (Abnahme-Befund: Teil-Übersicht durch frühes + Drainen).""" + fake_agents.standard_antworten(fake_welt) + repo = _repo(tmp_path) + ergebnis = await _scan(repo, monkeypatch) + assert ergebnis["status"] == "ok" + # Zustand eines abgebrochenen Laufs nachstellen: ein Chunk tot, Rest fertig + karten = await testdb.kanban_cards("mini", scan_board.BOARD, kind="chunk") + tot = karten[0]["card_id"] + await testdb.kanban_upsert_card("mini", scan_board.BOARD, tot, "chunk", "dead", None) + fake_welt.calls.clear() + ergebnis2 = await asyncio.wait_for( + scan_board.run_scan(repo, "mini", stand="deadbeef", fortsetzen=True), timeout=30) + assert ergebnis2["status"] == "ok", ergebnis2 + sichten_calls = [k for k in fake_welt.calls if "-sichten-" in k] + assert len(sichten_calls) == 3 # genau EINE Runde, kein Doppel-Drain + features = (repo / ".planer" / "features" / "fake-bereich.md").read_text() + assert "rechner.py::addiere" in features and "anzeige.py::zeige" in features # volle Übersicht + + +async def test_e2e_events_geschrieben(fake_welt, testdb, tmp_path, monkeypatch): + """Telemetrie: Agent-Events mit run_id landen in der DB.""" + import agents + import database + monkeypatch.setattr(agents, "on_event", database.add_event) + fake_agents.standard_antworten(fake_welt) + repo = _repo(tmp_path) + ergebnis = await _scan(repo, monkeypatch) + assert ergebnis["status"] == "ok" + db = await testdb.get_db() + cursor = await db.execute( + "SELECT count(*) FROM events WHERE topic='mini' AND kind='agent' AND run_id LIKE 'scan-%'") + assert (await cursor.fetchone())[0] >= 5 # 2 Chunks + 3 Sichten diff --git a/backend/tests/test_viewer.py b/backend/tests/test_viewer.py new file mode 100644 index 0000000..8e649de --- /dev/null +++ b/backend/tests/test_viewer.py @@ -0,0 +1,114 @@ +"""Viewer-Service: Parser, Drift, Doku-Ordnung, Projektliste.""" +from pathlib import Path + +import config +import projekte +import viewer + +MINI = Path(__file__).parent / "fixtures" / "mini_repo" + + +def test_lese_einheiten_mit_entscheidungen(): + text = """# Einheiten: a.py +stand: abc + +## a.py::eins +beschreibung: Macht eins. +input: x +output: y +entscheidungen: +- Erste Entscheidung. + beleg: "code hier" +- Zweite mit Umbruch + und Fortsetzung. +kanten: +- ruft-auf: a.py::zwei + +## b.py +beschreibung: Datei-Einheit. +""" + e = viewer.lese_einheiten(text) + eins = e["a.py::eins"] + assert eins["entscheidungen"] == ["Erste Entscheidung.", "Zweite mit Umbruch und Fortsetzung."] + assert eins["kanten"] == [{"typ": "ruft-auf", "ziel": "a.py::zwei"}] + assert (eins["input"], eins["output"]) == ("x", "y") + assert e["b.py"]["beschreibung"] == "Datei-Einheit." + + +def test_lese_kern_und_pruefung(): + kern = viewer.lese_kern("# Kern: demo\nZwei Sätze.\n\ntragende-einheiten: a.py::x, b.py::y\n") + assert kern["titel"] == "demo" and kern["tragende_einheiten"] == ["a.py::x", "b.py::y"] + pr = viewer.lese_pruefung("# Prüfung: demo\ntests: make test\nlint: (keins vorhanden)\n" + "start: make dev\nhinweise:\n- Vorsicht.\n") + assert pr["tests"] == "make test" and pr["hinweise"] == ["Vorsicht."] + + +def test_lese_features_architektur_flows(): + b = viewer.lese_features("# Bereich: rechnen\nbeschreibung: Rechnet.\n\n" + "## Feature: Addieren [kern]\nbeschreibung: Summen.\n\n" + "### Kann addieren\neinheiten: a.py::eins\n") + assert b["features"][0]["flag"] == "kern" + assert b["features"][0]["teilfeatures"][0]["einheiten"] == ["a.py::eins"] + a = viewer.lese_architektur("# Architektur: demo\n\n## Komponente: kernstück\n" + "beschreibung: Trägt.\neinheiten: a.py::eins\n" + "beziehungen:\n- nutzt: anzeige\n") + assert a[0]["beziehungen"] == [{"typ": "nutzt", "ziel": "anzeige"}] + f = viewer.lese_flows("# Flows: demo\n\n## Flow: ablauf\n1. Schritt eins — a.py::eins\n" + "2. Schritt ohne Referenz\n") + assert f[0]["schritte"][0]["einheiten"] == ["a.py::eins"] + assert f[0]["schritte"][1]["einheiten"] == [] + + +def test_code_extrahieren(): + assert "return a + b" in viewer.code_extrahieren(MINI, "rechner.py::addiere") + assert viewer.code_extrahieren(MINI, "rechner.py::BASIS").startswith("BASIS = 10") + assert viewer.code_extrahieren(MINI, "rechner.py::gibtsnicht") == "" + assert viewer.code_extrahieren(MINI, "wegdatei.py::x") == "" + assert "def merke" in viewer.code_extrahieren(MINI, "rechner.py::Speicher.merke") + + +async def test_lade_projekt_und_drift(gescanntes_repo): + wurzel, git = gescanntes_repo + projekt = viewer.lade_projekt(wurzel) + assert "rechner.py::addiere" in projekt["einheiten"] + assert projekt["kern"]["titel"] == "mini" + assert projekt["staende"]["rechner.py"] + assert viewer.drift(wurzel, projekt["staende"])["veraltet"] == [] + + (wurzel / "rechner.py").write_text((wurzel / "rechner.py").read_text() + "\nX2 = 2\n") + git("add", "-A") + git("commit", "-m", "aenderung") + d = viewer.drift(wurzel, projekt["staende"]) + assert d["veraltet"] == ["rechner.py"] # anzeige.py unverändert + + +def test_doku_ordnung_mit_zyklus(): + projekt = { + "bereiche": [ + {"name": "oben", "features": [{"teilfeatures": [{"einheiten": ["a.py::x"]}]}]}, + {"name": "unten", "features": [{"teilfeatures": [{"einheiten": ["b.py::y"]}]}]}, + ], + "einheiten": { + "a.py::x": {"kanten": [{"typ": "ruft-auf", "ziel": "b.py::y"}]}, + "b.py::y": {"kanten": []}, + }, + } + assert viewer.doku_ordnung(projekt) == ["unten", "oben"] # Fundament zuerst + # Zyklus: beide nutzen einander → deterministisch, beide enthalten + projekt["einheiten"]["b.py::y"]["kanten"] = [{"typ": "nutzt", "ziel": "a.py::x"}] + ordnung = viewer.doku_ordnung(projekt) + assert sorted(ordnung) == ["oben", "unten"] and len(ordnung) == 2 + + +def test_projektliste(tmp_path, monkeypatch): + echt = tmp_path / "echt" + echt.mkdir() + (tmp_path / "kopie").mkdir() + datei = tmp_path / "projekte.txt" + datei.write_text(f"# Kommentar\n{echt}\n{tmp_path}/weg\n{tmp_path}/kopie\n{echt}\n") + monkeypatch.setattr(config, "PROJEKTE_DATEI", datei) + liste = projekte.lade() + assert [p.get("fehler") is None for p in liste] == [True, False, True, False] + assert "existiert nicht" in liste[1]["fehler"] + assert "Namenskollision" in liste[3]["fehler"] + assert projekte.finde("echt") == echt and projekte.finde("weg") is None diff --git a/backend/viewer.py b/backend/viewer.py new file mode 100644 index 0000000..e2a9e85 --- /dev/null +++ b/backend/viewer.py @@ -0,0 +1,279 @@ +"""Viewer-Service: liest .planer/-Dateien eines Projekts in Strukturen für die API. + +Reine Bibliothek (kein FastAPI-Import). Eigener toleranter Lese-Parser — gates.py bleibt +unangetastet (scan-kritisch) und verwirft z. B. die Entscheidungs-SÄTZE, die die UI zeigt. +Code je Einheit wird LIVE aus dem Anker extrahiert, nie gespeichert (Single Source). +""" +import re +from pathlib import Path + +import artefakte +import repo + +_EINHEIT_KOPF = re.compile(r"^## (\S+::\S+|\S+\.\w+)$") + + +def lese_einheiten(text: str) -> dict[str, dict]: + """Einheiten-Datei → {id: {beschreibung, input, output, entscheidungen, kanten, anker}}.""" + out: dict[str, dict] = {} + aktuelle = None + modus = None + for zeile in text.splitlines(): + if (m := _EINHEIT_KOPF.match(zeile.strip())) and zeile.startswith("## "): + aktuelle = {"id": m.group(1), "beschreibung": "", "input": "", "output": "", + "entscheidungen": [], "kanten": [], "anker": []} + out[aktuelle["id"]] = aktuelle + modus = None + elif aktuelle is None: + continue + elif m := re.match(r"(beschreibung|input|output):(.*)$", zeile): + aktuelle[m.group(1)] = m.group(2).strip() + modus = m.group(1) + elif zeile.startswith("anker:"): + aktuelle["anker"].append(zeile.split(":", 1)[1].strip()) + elif zeile.strip() in ("entscheidungen:", "fakten:"): + modus = "punkte" + elif zeile.strip() == "kanten:": + modus = "kanten" + elif modus == "punkte" and re.match(r"\s+beleg:", zeile): + continue # UI zeigt echten Code statt Zitaten + elif modus == "punkte" and zeile.startswith("- "): + aktuelle["entscheidungen"].append(re.sub(r"\s*\bbeleg:.*$", "", zeile[2:]).strip()) + elif modus == "punkte" and zeile.startswith(" ") and aktuelle["entscheidungen"]: + aktuelle["entscheidungen"][-1] += " " + zeile.strip() + elif modus == "kanten" and (m := re.match(r"- ([\wäöü-]+):\s*(\S+)", zeile)): + aktuelle["kanten"].append({"typ": m.group(1), "ziel": m.group(2)}) + elif modus in ("beschreibung", "input", "output") and zeile.startswith(" "): + aktuelle[modus] += " " + zeile.strip() + return out + + +def lese_kern(text: str) -> dict: + zeilen = text.splitlines() + titel = zeilen[0].removeprefix("# Kern:").strip() if zeilen else "" + tragend: list[str] = [] + rumpf: list[str] = [] + for zeile in zeilen[1:]: + if zeile.startswith("tragende-einheiten:"): + tragend = [t.strip() for t in zeile.split(":", 1)[1].split(",") if t.strip()] + else: + rumpf.append(zeile) + return {"titel": titel, "text": "\n".join(rumpf).strip(), "tragende_einheiten": tragend} + + +def _einheiten_refs(zeile: str) -> list[str]: + return [t.strip() for t in zeile.split(":", 1)[1].split(",") if t.strip()] + + +def lese_features(text: str) -> dict: + """Eine Bereichs-Datei → {name, beschreibung, features: [{titel, flag, beschreibung, + teilfeatures: [{titel, einheiten}]}]}.""" + bereich = {"name": "", "beschreibung": "", "features": []} + feature = None + for zeile in text.splitlines(): + if zeile.startswith("# Bereich:"): + bereich["name"] = zeile.split(":", 1)[1].strip() + feature = None + elif zeile.startswith("## Feature:"): + titel = zeile[11:].strip() + flag = "kern" if "[kern]" in titel else "rand" + feature = {"titel": re.sub(r"\s*\[(kern|rand)\]", "", titel).strip(), + "flag": flag, "beschreibung": "", "teilfeatures": []} + bereich["features"].append(feature) + elif zeile.startswith("### ") and feature is not None: + feature["teilfeatures"].append({"titel": zeile[4:].strip(), "einheiten": []}) + elif zeile.startswith("einheiten:") and feature and feature["teilfeatures"]: + feature["teilfeatures"][-1]["einheiten"] = _einheiten_refs(zeile) + elif zeile.startswith("beschreibung:"): + ziel = feature if feature is not None else bereich + ziel["beschreibung"] = zeile.split(":", 1)[1].strip() + return bereich + + +def lese_architektur(text: str) -> list[dict]: + komponenten: list[dict] = [] + k = None + modus = None + for zeile in text.splitlines(): + if zeile.startswith("## Komponente:"): + k = {"name": zeile.split(":", 1)[1].strip(), "beschreibung": "", + "einheiten": [], "beziehungen": []} + komponenten.append(k) + modus = None + elif k is None: + continue + elif zeile.startswith("beschreibung:"): + k["beschreibung"] = zeile.split(":", 1)[1].strip() + elif zeile.startswith("einheiten:"): + k["einheiten"] = _einheiten_refs(zeile) + elif zeile.strip() == "beziehungen:": + modus = "beziehungen" + elif modus == "beziehungen" and (m := re.match(r"- ([\wäöü-]+):\s*(.+)$", zeile)): + k["beziehungen"].append({"typ": m.group(1), "ziel": m.group(2).strip()}) + return komponenten + + +def lese_flows(text: str) -> list[dict]: + flows: list[dict] = [] + f = None + for zeile in text.splitlines(): + if zeile.startswith("## Flow:"): + f = {"titel": zeile.split(":", 1)[1].strip(), "schritte": []} + flows.append(f) + elif f is not None and (m := re.match(r"^\d+\.\s(.+?)(?:\s—\s(.+))?$", zeile)): + refs = [t.strip() for t in (m.group(2) or "").split(",") if t.strip()] + f["schritte"].append({"text": m.group(1).strip(), "einheiten": refs}) + return flows + + +def lese_pruefung(text: str) -> dict: + out = {"tests": "", "lint": "", "start": "", "hinweise": []} + modus = None + for zeile in text.splitlines(): + if m := re.match(r"(tests|lint|start):(.*)$", zeile): + out[m.group(1)] = m.group(2).strip() + modus = None + elif zeile.strip() == "hinweise:": + modus = "hinweise" + elif modus == "hinweise" and zeile.startswith("- "): + out["hinweise"].append(zeile[2:].strip()) + return out + + +def code_extrahieren(wurzel: Path, eid: str) -> str: + """Quellcode eines Ankers (pfad::symbol) LIVE aus der Quelle — nie Exception: + fehlende Datei/Symbol → '' (UI zeigt Hinweis).""" + try: + datei, _, symbol = eid.partition("::") + p = wurzel / datei + if not p.is_file(): + return "" + text = p.read_text(encoding="utf-8", errors="replace") + if not symbol: + return text[:8000] # Datei-Einheit: ganze (gekappte) Datei + if "." in symbol: + symbol = symbol.split(".", 1)[1] # qualifizierte Methode → Methode suchen + zeilen = text.splitlines() + start = None + for i, z in enumerate(zeilen): + if re.match(rf"(\s*)(?:async\s+)?(?:def|class)\s+{re.escape(symbol)}\b", z): + start = i + break + if re.match(rf"{re.escape(symbol)}\s*[:=]", z): + start = i + ende = i + 1 + while ende < len(zeilen) and (zeilen[ende].startswith((" ", "\t", ")", "]", "}")) + or not zeilen[ende].strip()): + ende += 1 + return "\n".join(zeilen[start:ende]).rstrip() + if start is None: + return "" + einzug = len(zeilen[start]) - len(zeilen[start].lstrip()) + ende = start + 1 + while ende < len(zeilen): + z = zeilen[ende] + if z.strip() and (len(z) - len(z.lstrip())) <= einzug: + break + ende += 1 + return "\n".join(zeilen[start:ende]).rstrip() + except Exception: + return "" + + +def lade_projekt(wurzel: Path) -> dict: + """Alle .planer/-Dateien eines Projekts → Struktur für die API. Fehlende Dateien + ergeben leere Teile (degradieren, nie werfen).""" + planer = wurzel / ".planer" + + def text(rel: str) -> str: + p = planer / rel + return p.read_text(encoding="utf-8") if p.is_file() else "" + + einheiten: dict[str, dict] = {} + staende: dict[str, str] = {} # quelldatei → stand + for p in sorted((planer / "einheiten").glob("*.md")) if (planer / "einheiten").is_dir() else []: + inhalt = p.read_text(encoding="utf-8") + einheiten.update(lese_einheiten(inhalt)) + kopf = inhalt.splitlines()[0] if inhalt else "" + datei = kopf.removeprefix("# Einheiten:").strip() + if datei and (stand := artefakte.lese_stand(inhalt)): + staende[datei] = stand + bereiche = [lese_features((planer / "features" / p.name).read_text(encoding="utf-8")) + for p in sorted((planer / "features").glob("*.md"))] \ + if (planer / "features").is_dir() else [] + return { + "kern": lese_kern(text("kern.md")), + "bereiche": bereiche, + "architektur": lese_architektur(text("architektur.md")), + "flows": lese_flows(text("flows.md")), + "pruefung": lese_pruefung(text("pruefung.md")), + "einheiten": einheiten, + "staende": staende, + } + + +# --- Drift --------------------------------------------------------------------------- + +_diff_cache: dict[tuple[str, str, str], set[str]] = {} # (pfad, stand, head) → geändert + + +def drift(wurzel: Path, staende: dict[str, str]) -> dict: + """Welche gescannten Quelldateien sind seit ihrem stand: berührt? + → {head, veraltet: [quelldatei]}. Cache-Schlüssel enthält HEAD → selbst-invalidierend.""" + try: + head = repo.head_hash(wurzel) + except (RuntimeError, FileNotFoundError): + return {"head": "", "veraltet": []} + veraltet = [] + for datei, stand in sorted(staende.items()): + if stand == head: + continue + schluessel = (str(wurzel), stand, head) + if schluessel not in _diff_cache: + try: + _diff_cache[schluessel] = repo.geaenderte_dateien(wurzel, stand)[0] + except RuntimeError: + _diff_cache[schluessel] = set() + if datei in _diff_cache[schluessel]: + veraltet.append(datei) + return {"head": head, "veraltet": veraltet} + + +# --- Doku-Leseordnung ------------------------------------------------------------------ + +def doku_ordnung(projekt: dict) -> list[str]: + """Bereichs-Namen in Abhängigkeitsordnung: Kanten der Einheiten (ruft-auf/nutzt) werden + zu Bereichs-Kanten aggregiert; viel Genutztes kommt früher (Kahn-Toposort, zyklenfest: + bei Zyklus gewinnt der Bereich mit kleinstem In-Degree, dann alphabetisch).""" + einheit_zu_bereich: dict[str, str] = {} + for bereich in projekt["bereiche"]: + for f in bereich["features"]: + for tf in f["teilfeatures"]: + for eid in tf["einheiten"]: + einheit_zu_bereich.setdefault(eid, bereich["name"]) + namen = [b["name"] for b in projekt["bereiche"]] + eingehend: dict[str, set[str]] = {n: set() for n in namen} + for eid, e in projekt["einheiten"].items(): + von = einheit_zu_bereich.get(eid) + for kante in e["kanten"]: + if kante["typ"] not in ("ruft-auf", "nutzt"): + continue + nach = einheit_zu_bereich.get(kante["ziel"]) + if von and nach and von != nach: + eingehend[nach].add(von) # "von nutzt nach" → nach ist Fundament → früher + # Kahn: Bereiche ohne offene Nutzer-Abhängigkeit zuerst — Fundament vor Nutzern: + # ein Bereich kommt, sobald alles, was ER nutzt, schon gelesen wurde. + nutzt: dict[str, set[str]] = {n: set() for n in namen} + for nach, nutzer in eingehend.items(): + for von in nutzer: + nutzt[von].add(nach) + ordnung: list[str] = [] + offen = set(namen) + while offen: + bereit = sorted(n for n in offen if not (nutzt[n] & offen)) + if not bereit: # Zyklus: kleinste offene Abhängigkeitszahl, dann Name + bereit = [min(offen, key=lambda n: (len(nutzt[n] & offen), n))] + for n in bereit: + ordnung.append(n) + offen.discard(n) + return ordnung diff --git a/dev-ops/opencode-slim.json b/dev-ops/opencode-slim.json new file mode 100644 index 0000000..b0089b7 --- /dev/null +++ b/dev-ops/opencode-slim.json @@ -0,0 +1,113 @@ +// Auto-Ableitung von opencode.json OHNE mcp-Server: Batch-Agenten (files/readonly/text) +// brauchen keine Web-MCPs — jeder opencode-Prozess startet sonst ~3 MCP-Prozesse (~300 MB). +// Bei Änderungen an opencode.json hier nachziehen (nur der mcp-Block fehlt). +{ + "$schema": "https://opencode.ai/config.json", + "provider": { + "minimax": { + "options": { + "apiKey": "{env:MINIMAX_API_KEY}" + }, + "models": { + "MiniMax-M3": { + "name": "MiniMax M3" + } + } + }, + "minimax-kalt": { + "npm": "@ai-sdk/anthropic", + "name": "MiniMax (kalt — niedrige Temperature, ohne Thinking)", + "options": { + "baseURL": "https://api.minimax.io/anthropic/v1", + "apiKey": "{env:MINIMAX_API_KEY}" + }, + "models": { + "MiniMax-M3": { + "name": "MiniMax M3 (kalt)", + "options": { + "temperature": 0.2, + "thinking": { + "type": "disabled" + } + } + }, + "MiniMax-M2.7-highspeed": { + "name": "MiniMax M2.7 highspeed (kalt)", + "options": { + "temperature": 0.3 + } + } + } + }, + "ollama": { + "npm": "@ai-sdk/openai-compatible", + "name": "Ollama (lokal)", + "options": { + "baseURL": "http://localhost:11434/v1" + }, + "models": { + "qwen3.6:27b": { + "name": "Qwen3.6 27B" + }, + "qwen3.5:9b": { + "name": "Qwen3.5 9B" + } + } + } + }, + "agent": { + "full": { + "description": "Alle Tools: Dateien, Bash, Websuche", + "permission": { + "edit": "allow", + "bash": "allow", + "webfetch": "allow" + } + }, + "files": { + "description": "Dateien lesen/schreiben + Bash, keine Websuche", + "permission": { + "edit": "allow", + "bash": "allow", + "webfetch": "deny" + }, + "tools": { + "minimax-search*": false, + "searxng*": false + } + }, + "readonly": { + "description": "Nur Dateien lesen", + "permission": { + "edit": "deny", + "bash": "deny", + "webfetch": "deny" + }, + "tools": { + "write": false, + "edit": false, + "bash": false, + "minimax-search*": false, + "searxng*": false + } + }, + "text": { + "description": "Reine Textantwort, keine Tools", + "permission": { + "edit": "deny", + "bash": "deny", + "webfetch": "deny" + }, + "tools": { + "write": false, + "edit": false, + "bash": false, + "read": false, + "glob": false, + "grep": false, + "minimax-search*": false, + "searxng*": false + } + } + } +} diff --git a/docs/format.md b/docs/format.md new file mode 100644 index 0000000..a1d5657 --- /dev/null +++ b/docs/format.md @@ -0,0 +1,184 @@ +# `.planer/`-Dateiformat (Spezifikation, Phase 0) + +Format der Wissensschichten im Projekt-Repo. Entwurf — wird in Phase 0 gegen echte +Scan-Ergebnisse am Creator validiert und nachgeschärft. + +## Design-Entscheidungen + +- **Markdown mit einfachen `schlüssel: wert`-Zeilen**, kein reines YAML/JSON: Menschen + lesen und editieren die Dateien direkt (Soll-Änderungen!), Agenten schreiben sie, + Skripte parsen sie mit simplen Regeln (Überschriften-Ebenen + Schlüsselzeilen). +- **Einheiten-ID = `pfad::symbol`** (z. B. `backend/kanban.py::_worker`) — stabil, + ableitbar, ohne separate ID-Verwaltung. Bei Datei-Ebene ohne Symbol: nur `pfad`. +- **Belege = wörtliche Kurzzitate** aus dem Code (nicht Zeilennummern — die verschieben + sich bei jedem Diff). Mechanisch prüfbar per Substring-Suche in der Anker-Datei. + Ein Beleg ist ein Ausschnitt aus GENAU EINER Quellzeile (Phase-0-Erkenntnis: + Modelle ziehen sonst mehrzeilige Statements zusammen — nicht prüfbar). +- **Eine Einheiten-Datei pro Quelldatei** (nicht pro Einheit — sonst hunderte Dateien; + nicht eine große — sonst Merge-Hölle). Diff-Lokalität: Quelldatei ändert sich → + genau eine Einheiten-Datei ändert sich. +- **Sichten referenzieren Einheiten nur per ID**, kopieren nie Fakten (Single Source). + +## Verzeichnis-Layout + +``` +/.planer/ + kern.md Kern des Projekts + tragende Einheiten + architektur.md Komponenten + Beziehungen + flows.md Abläufe als Schrittfolgen + features/.md eine Datei je Funktionsbereich + einheiten/.md eine Datei je Quelldatei (Pfad, `/` → `__`) + pruefung.md Build-/Test-/Start-Kommandos, Eigenheiten + entscheidungen/*.md Decision Records + strategie/*.md benannte Soll-Entwürfe + ideen.md Ideen-Backlog + jourfixe/*.md Sitzungsprotokolle +``` + +## Einheiten: `einheiten/backend__kanban.py.md` + +````markdown +# Einheiten: backend/kanban.py +stand: 3f2a91c ← Commit-Hash des letzten Scans dieser Datei (der Anker-Stand) + +## backend/kanban.py::_worker +beschreibung: Zieht Karten aus der Stufe der Spalte und arbeitet sie nebenläufig ab. +input: Flow, Stage-Spezifikation, Inflight-Limit, Liste aller Stage-Namen +output: kehrt erst zurück, wenn flowweit nichts mehr zu tun ist; Karten sind advanced, + im Backoff oder dead +entscheidungen: +- Exit erst nach doppelter Leerlauf-Prüfung mit Karenz-Schlaf. + beleg: "if await _idle_exit():" +- Ein Barriere-Worker zieht nur bei Quieszenz aller Upstream-Stufen. + beleg: "return await quiescent(flow, spec.upstream)" +kanten: +- ruft-auf: backend/kanban.py::quiescent +- nutzt: backend/database.py::kanban_pull +- wird-genutzt-von: backend/kanban.py::run_flow +```` + +Regeln: +- `## `-Überschrift = Einheiten-ID. Freitext darunter bis zur nächsten Schlüsselzeile + ist verboten — nur `beschreibung:`, `input:`, `output:`, `entscheidungen:`, `kanten:` + (feste Reihenfolge). +- `beschreibung:` genau ein Satz (die Verantwortung), Umbruch mit Einrückung erlaubt. +- `input:` was die Einheit entgegennimmt, `output:` was sie liefert bzw. bewirkt — + je eine knappe Zeile, keine Prosa. +- Jede Entscheidung: kurzer Satz (`- `-Zeile) — eine im Code getroffene Design- + Entscheidung oder Garantie, kein Implementierungs-Nacherzählen — gefolgt von + `beleg: ""`. +- **Der konkrete Code wird nie in Artefakte kopiert** — die UI zieht ihn live über den + Anker (Pfad + Symbol) aus der Quelle. Single Source, kein Drift. +- `kanten:`-Typen: `ruft-auf`, `nutzt`, `wird-genutzt-von`, `löst-aus`, `wird-ausgelöst-von`. + Ziel ist immer eine Einheiten-ID. +- MECE-Anspruch v1: Symbol-Ebene; Kleinkram (Imports, Konstanten) darf unzugeordnet + bleiben. Jede Funktion/Klasse der Quelldatei gehört zu genau einer Einheit (eine + Einheit darf mehrere kleine, zusammengehörige Symbole bündeln — dann mehrere + `anker:`-Zeilen unter der Überschrift, ID ist der Hauptanker). + +## Feature-Sicht: `features/.md` + +````markdown +# Bereich: Generierungs-Pipeline +beschreibung: Erzeugt aus einer Quelle die Lerninhalte in drei Board-Stufen. + +## Feature: Resümierbare Kanban-Boards [kern] +beschreibung: Generierung läuft als Karten durch Spalten und übersteht Abbrüche. + +### Kann nach Abbruch fortsetzen +einheiten: backend/kanban.py::run_flow, backend/database.py::kanban_pull + +### Fehlerhafte Karten landen sichtbar im Dead-Letter +einheiten: backend/kanban.py::_worker +```` + +Regeln: +- `# Bereich` → `## Feature` → `### Teilfeature`; Flag `[kern]` oder `[rand]` am Feature. +- **Titel kurz, ohne Klammern, ohne „und"** — ein Bereich/Feature erfüllt genau EINE + Aufgabe; wer „und" braucht, muss splitten. Beschreibungen: ein kurzer Satz, der den + Kern trifft, ebenfalls ohne „und"-Aufzählung. +- Teilfeatures tragen NUR `einheiten:`-Referenzen (+ optional `beschreibung:`). + Alles Weitere zieht die UI live aus den Einheiten: die Entscheidungs-Liste + (aggregiert über die referenzierten Einheiten), je Methode Input/Output und den + konkreten Code aus dem Anker. +- MECE je Ebene: Bereiche zerlegen das Projekt, Features ihren Bereich, Teilfeatures + ihr Feature — vollständig, überschneidungsfrei. Richtwert 6–10 Bereiche, 5–15 + Features je Bereich. + +## Kern: `kern.md` + +````markdown +# Kern: creator +Aus einem Thema/Skript/Ordner/Link entsteht ein vollständiger, belegter Lernguide +mit Übungssystem — zerlegt nach MECE, jede Aussage mit Beleg. + +tragende-einheiten: backend/kanban.py::run_flow, backend/board_inventory.py, … +```` + +Wenige Sätze; `tragende-einheiten:` verweist auf das, was das Projekt trägt. + +## Architektur: `architektur.md` + +````markdown +# Architektur: creator + +## Komponente: Kanban-Engine +beschreibung: Generischer Streaming-Motor; Boards definieren die Stufen. +einheiten: backend/kanban.py::Flow, backend/kanban.py::_worker, … +beziehungen: +- nutzt: Komponente: Datenbank +- wird-genutzt-von: Komponente: Boards +```` + +Komponenten-Beziehungen werden aus den Einheiten-Kanten aggregiert und beim Scan +gegen sie geprüft (keine Beziehung ohne mindestens eine tragende Kante). + +## Flows: `flows.md` + +````markdown +# Flows: creator + +## Flow: Thema → fertiger Guide +1. Research-Agenten sammeln Quellen — backend/board_inventory.py::research +2. Titel werden geclustert und benannt — backend/board_inventory.py::cluster +3. … +```` + +Nummerierte Schritte, jeder Schritt endet mit ` — [, ]`. + +## Prüfung: `pruefung.md` + +````markdown +# Prüfung: creator +tests: make test +lint: (keins vorhanden) +start: make dev +hinweise: +- Backend-Edits bei laufendem Flow triggern uvicorn-Reload und killen Läufe. +```` + +Feste Schlüssel `tests:`, `lint:`, `start:`; fehlt etwas, steht dort explizit +`(keins vorhanden)` — Gates degradieren sichtbar, nie still. + +## Decision Record: `entscheidungen/-.md` + +````markdown +# Entscheidung: Belege als Kurzzitate statt Zeilennummern +datum: 2026-07-09 +status: aktiv +betrifft: einheiten-format +frage: Wie referenzieren Fakten die Code-Stelle? +optionen: Zeilennummern (präzise, aber driften) | Kurzzitate (robust, substring-prüfbar) +entscheidung: Kurzzitate. +begründung: Zeilennummern veralten bei jedem Diff; Zitate sind mechanisch prüfbar. +```` + +## Mechanische Prüfungen (Skripte, tokenfrei) + +1. **Anker-Existenz**: jede Einheiten-ID zeigt auf existierende Datei + Symbol darin. +2. **Zitat-Treue**: jeder `beleg:`-String kommt wörtlich in der Anker-Datei vor. +3. **Referenz-Integrität**: jede `einheiten:`-Referenz in Sichten existiert; jedes + Kanten-Ziel existiert. +4. **Abdeckung**: jedes Symbol der Quelldatei ist einer Einheit zugeordnet (Report, + v1 kein harter Fehler). +5. **Struktur**: Dateien folgen der Grammatik (Schlüssel, Reihenfolge, Flags). diff --git a/frontend/dist/assets/index-AxkPXHNh.css b/frontend/dist/assets/index-AxkPXHNh.css new file mode 100644 index 0000000..144f47f --- /dev/null +++ b/frontend/dist/assets/index-AxkPXHNh.css @@ -0,0 +1 @@ +.karte[data-v-f7a93d8e]{background:var(--panel);border:1px solid var(--rand);border-radius:10px;padding:1rem 1.2rem}.karte.tot[data-v-f7a93d8e]{opacity:.7}.zeile[data-v-f7a93d8e]{align-items:baseline;gap:.6rem;display:flex}.name[data-v-f7a93d8e]{color:var(--text);font-weight:600;text-decoration:none}a.name[data-v-f7a93d8e]:hover{color:var(--akzent)}.detail[data-v-f7a93d8e]{color:var(--dezent);overflow-wrap:anywhere;margin:.3rem 0 0;font-size:.85rem}.drift[data-v-f7a93d8e]{color:var(--gelb)}.aktionen[data-v-f7a93d8e]{margin-top:.7rem}.meldung[data-v-f7a93d8e]{color:var(--rot);margin:.5rem 0 0;font-size:.85rem}.liste[data-v-78297d84]{grid-template-columns:repeat(auto-fill,minmax(320px,1fr));gap:1rem;display:grid}.fehler[data-v-78297d84]{color:var(--rot)}.leer[data-v-78297d84]{color:var(--dezent)}.bereich[data-v-f039a64a]{margin-bottom:1.6rem}.bereich h3[data-v-f039a64a]{margin:0 0 .1rem;font-size:1.05rem}.bereich>.besch[data-v-f039a64a]{margin:0 0 .7rem}.besch[data-v-f039a64a]{color:var(--dezent);margin:.3rem 0 0;font-size:.9rem}.raster[data-v-f039a64a]{grid-template-columns:repeat(auto-fill,minmax(300px,1fr));gap:.8rem;display:grid}.feature[data-v-f039a64a]{cursor:pointer}.feature[data-v-f039a64a]:hover{border-color:var(--akzent)}.feature.offen[data-v-f039a64a]{grid-column:1/-1}.kopf[data-v-f039a64a]{align-items:baseline;gap:.6rem;display:flex}.faehigkeiten[data-v-f039a64a]{margin:.6rem 0 0;padding-left:1.3rem}.faehigkeiten li[data-v-f039a64a]{margin:.25rem 0}.mehr[data-v-f039a64a]{color:var(--akzent);margin-top:.5rem;font-size:.82rem;display:block}.einheit[data-v-58d66282]{border:1px solid var(--rand);background:var(--bg);border-radius:8px;margin:.3rem 0 .5rem 1.1rem}.einheit>summary[data-v-58d66282]{gap:.5rem;padding:.4rem .6rem;font-size:.82rem;display:flex}.inhalt[data-v-58d66282]{padding:.1rem .8rem .7rem;font-size:.9rem}.besch[data-v-58d66282]{margin:.2rem 0}.io[data-v-58d66282]{color:var(--dezent);grid-template-columns:max-content 1fr;gap:.1rem .7rem;margin:.3rem 0;font-size:.85rem;display:grid}.io dt[data-v-58d66282]{font-weight:600}.io dd[data-v-58d66282]{margin:0}.entscheidungen[data-v-58d66282]{margin:.3rem 0;padding-left:1.2rem}.entscheidungen li[data-v-58d66282]{margin:.15rem 0}.kanten[data-v-58d66282]{color:var(--dezent);font-size:.82rem}.kein-code[data-v-58d66282]{color:var(--gelb);font-size:.85rem}.fehler[data-v-58d66282]{color:var(--rot)}.laden[data-v-58d66282]{color:var(--dezent)}.komponente[data-v-dc3c6459]{background:var(--panel);border:1px solid var(--rand);border-radius:10px;margin-bottom:1rem;padding:.9rem 1.2rem}.komponente h3[data-v-dc3c6459]{margin:0;font-size:1.02rem}.besch[data-v-dc3c6459]{color:var(--dezent);margin:.2rem 0;font-size:.9rem}.beziehungen[data-v-dc3c6459]{color:var(--akzent);margin:.2rem 0 .5rem;font-size:.85rem}summary[data-v-dc3c6459]{color:var(--dezent);padding:.3rem 0;font-size:.9rem}.leer[data-v-dc3c6459]{color:var(--dezent)}.flow[data-v-9b2e52a0]{background:var(--panel);border:1px solid var(--rand);border-radius:10px;margin-bottom:1rem;padding:.9rem 1.2rem}.flow h3[data-v-9b2e52a0]{margin:0 0 .4rem;font-size:1.02rem}.flow li[data-v-9b2e52a0]{margin:.3rem 0}.refs>summary[data-v-9b2e52a0]{color:var(--dezent);padding:.15rem 0;font-size:.8rem}.leer[data-v-9b2e52a0]{color:var(--dezent)}.pruefung[data-v-480e8270]{background:var(--panel);border:1px solid var(--rand);border-radius:10px;padding:.9rem 1.2rem}dl[data-v-480e8270]{grid-template-columns:max-content 1fr;gap:.3rem 1rem;margin:0;display:grid}dt[data-v-480e8270]{font-weight:600}dd[data-v-480e8270]{margin:0}ul[data-v-480e8270]{color:var(--dezent);margin:.7rem 0 0}.doku h2[data-v-b57ab26e]{color:var(--dezent);margin:1.4rem 0 .6rem;font-size:1.05rem}.doku h2[data-v-b57ab26e]:first-child{margin-top:0}.leiste[data-v-5d2db867]{background:var(--panel);border:1px solid var(--rand);border-radius:10px;align-self:start;padding:.9rem 1.1rem;position:sticky;top:1rem}.leiste h3[data-v-5d2db867]{margin:0 0 .5rem;font-size:.95rem}.leiste h4[data-v-5d2db867]{color:var(--dezent);text-transform:uppercase;letter-spacing:.04em;margin:.7rem 0 .3rem;font-size:.8rem}.stufen[data-v-5d2db867]{grid-template-columns:1fr max-content;gap:.15rem .8rem;margin:0;font-size:.85rem;display:grid}.stufen dt[data-v-5d2db867]{color:var(--dezent)}.stufen dd[data-v-5d2db867]{text-align:right;margin:0}.agent[data-v-5d2db867]{overflow-wrap:anywhere;margin:.2rem 0;font-size:.78rem}.dead[data-v-5d2db867]{color:var(--rot);margin:.6rem 0 0;font-size:.82rem}.rahmen.mitLeiste[data-v-50cf4d28]{grid-template-columns:1fr 300px;gap:1.2rem;display:grid}.kern[data-v-50cf4d28]{margin-bottom:1.2rem}.kern h2[data-v-50cf4d28]{margin:0 0 .4rem;font-size:1.2rem}.kern-text[data-v-50cf4d28] p{color:var(--dezent);margin:.3rem 0}.drift-hinweis[data-v-50cf4d28]{color:var(--gelb);margin:.6rem 0 0;font-size:.88rem}.fehler[data-v-50cf4d28]{color:var(--rot)}.laden[data-v-50cf4d28]{color:var(--dezent)}.shell[data-v-bb207b1a]{grid-template-columns:220px 1fr;min-height:100vh;display:grid}.sidebar[data-v-bb207b1a]{background:var(--panel);border-right:1px solid var(--rand);flex-direction:column;gap:1.2rem;height:100vh;padding:1rem .8rem;display:flex;position:sticky;top:0;overflow-y:auto}.sidebar h1[data-v-bb207b1a]{cursor:pointer;margin:0 0 .2rem .4rem;font-size:1.1rem}.gruppe[data-v-bb207b1a]{text-transform:uppercase;letter-spacing:.06em;color:var(--dezent);margin:0 0 .3rem .4rem;font-size:.7rem;font-weight:600;display:block}nav[data-v-bb207b1a]{flex-direction:column;gap:.1rem;display:flex}nav a[data-v-bb207b1a]{color:var(--text);border-radius:7px;align-items:center;gap:.5rem;padding:.4rem .6rem;font-size:.92rem;text-decoration:none;display:flex}nav a[data-v-bb207b1a]:hover{background:var(--bg)}nav a.aktiv[data-v-bb207b1a]{background:var(--akzent);color:var(--akzent-text)}nav a.gestoert[data-v-bb207b1a]{color:var(--dezent);cursor:default}.icon[data-v-bb207b1a]{text-align:center;width:1.1rem;color:inherit;opacity:.75}.punkt[data-v-bb207b1a]{border-radius:99px;width:8px;height:8px;margin-left:auto}.punkt.gruen[data-v-bb207b1a]{background:var(--gruen)}.punkt.gelb[data-v-bb207b1a]{background:var(--gelb)}.dark-knopf[data-v-bb207b1a]{margin-top:auto}main[data-v-bb207b1a]{max-width:1100px;padding:1.4rem 1.8rem}:root{--bg:#f6f7f9;--panel:#fff;--text:#1a202c;--dezent:#64748b;--rand:#e2e8f0;--akzent:#2563eb;--akzent-text:#fff;--gruen:#16a34a;--gruen-bg:#dcfce7;--gelb:#b45309;--gelb-bg:#fef3c7;--rot:#b91c1c;--rot-bg:#fee2e2;--code-bg:#f1f5f9}html.dark{--bg:#0f1420;--panel:#1a2130;--text:#e2e8f0;--dezent:#94a3b8;--rand:#2d3748;--akzent:#60a5fa;--akzent-text:#0f1420;--gruen:#86efac;--gruen-bg:#14532d;--gelb:#fcd34d;--gelb-bg:#451a03;--rot:#fca5a5;--rot-bg:#450a0a;--code-bg:#111827}*{box-sizing:border-box}body{background:var(--bg);color:var(--text);margin:0;font:15px/1.55 system-ui,sans-serif}button{font:inherit;cursor:pointer;border:1px solid var(--rand);background:var(--panel);color:var(--text);border-radius:6px;padding:.35rem .8rem}button.primaer{background:var(--akzent);color:var(--akzent-text);border-color:var(--akzent)}button:disabled{opacity:.5;cursor:default}.karte{background:var(--panel);border:1px solid var(--rand);border-radius:10px;padding:.9rem 1.1rem}.badge{text-transform:uppercase;letter-spacing:.04em;border-radius:99px;padding:.1rem .5rem;font-size:.72rem;font-weight:600}.badge.gruen{color:var(--gruen);background:var(--gruen-bg)}.badge.gelb{color:var(--gelb);background:var(--gelb-bg)}.badge.rot{color:var(--rot);background:var(--rot-bg)}pre{background:var(--code-bg);border-radius:6px;padding:.6rem .8rem;font-size:.78rem;line-height:1.45;overflow-x:auto}details>summary{cursor:pointer;list-style:none}details>summary:before{content:"▸";color:var(--dezent);margin-right:.4rem;font-size:.8em;transition:transform .12s;display:inline-block}details[open]>summary:before{transform:rotate(90deg)} diff --git a/frontend/dist/assets/index-DIiv29cS.js b/frontend/dist/assets/index-DIiv29cS.js new file mode 100644 index 0000000..1dc49c9 --- /dev/null +++ b/frontend/dist/assets/index-DIiv29cS.js @@ -0,0 +1,64 @@ +(function(){let e=document.createElement(`link`).relList;if(e&&e.supports&&e.supports(`modulepreload`))return;for(let e of document.querySelectorAll(`link[rel="modulepreload"]`))n(e);new MutationObserver(e=>{for(let t of e)if(t.type===`childList`)for(let e of t.addedNodes)e.tagName===`LINK`&&e.rel===`modulepreload`&&n(e)}).observe(document,{childList:!0,subtree:!0});function t(e){let t={};return e.integrity&&(t.integrity=e.integrity),e.referrerPolicy&&(t.referrerPolicy=e.referrerPolicy),e.crossOrigin===`use-credentials`?t.credentials=`include`:e.crossOrigin===`anonymous`?t.credentials=`omit`:t.credentials=`same-origin`,t}function n(e){if(e.ep)return;e.ep=!0;let n=t(e);fetch(e.href,n)}})();function e(e){let t=Object.create(null);for(let n of e.split(`,`))t[n]=1;return e=>e in t}var t={},n=[],r=()=>{},i=()=>!1,a=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),o=e=>e.startsWith(`onUpdate:`),s=Object.assign,c=(e,t)=>{let n=e.indexOf(t);n>-1&&e.splice(n,1)},l=Object.prototype.hasOwnProperty,u=(e,t)=>l.call(e,t),d=Array.isArray,f=e=>x(e)===`[object Map]`,p=e=>x(e)===`[object Set]`,m=e=>x(e)===`[object Date]`,h=e=>typeof e==`function`,g=e=>typeof e==`string`,_=e=>typeof e==`symbol`,v=e=>typeof e==`object`&&!!e,y=e=>(v(e)||h(e))&&h(e.then)&&h(e.catch),b=Object.prototype.toString,x=e=>b.call(e),ee=e=>x(e).slice(8,-1),S=e=>x(e)===`[object Object]`,C=e=>g(e)&&e!==`NaN`&&e[0]!==`-`&&``+parseInt(e,10)===e,te=e(`,key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted`),ne=e=>{let t=Object.create(null);return(n=>t[n]||(t[n]=e(n)))},re=/-\w/g,w=ne(e=>e.replace(re,e=>e.slice(1).toUpperCase())),ie=/\B([A-Z])/g,T=ne(e=>e.replace(ie,`-$1`).toLowerCase()),ae=ne(e=>e.charAt(0).toUpperCase()+e.slice(1)),oe=ne(e=>e?`on${ae(e)}`:``),E=(e,t)=>!Object.is(e,t),se=(e,...t)=>{for(let n=0;n{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:r,value:n})},ce=e=>{let t=parseFloat(e);return isNaN(t)?e:t},le,ue=()=>le||=typeof globalThis<`u`?globalThis:typeof self<`u`?self:typeof window<`u`?window:typeof global<`u`?global:{};function de(e){if(d(e)){let t={};for(let n=0;n{if(e){let n=e.split(pe);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function O(e){let t=``;if(g(e))t=e;else if(d(e))for(let n=0;n!!(e&&e.__v_isRef===!0),k=e=>g(e)?e:e==null?``:d(e)||v(e)&&(e.toString===b||!h(e.toString))?xe(e)?k(e.value):JSON.stringify(e,Se,2):String(e),Se=(e,t)=>xe(t)?Se(e,t.value):f(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((e,[t,n],r)=>(e[Ce(t,r)+` =>`]=n,e),{})}:p(t)?{[`Set(${t.size})`]:[...t.values()].map(e=>Ce(e))}:_(t)?Ce(t):v(t)&&!d(t)&&!S(t)?String(t):t,Ce=(e,t=``)=>_(e)?`Symbol(${e.description??t})`:e,A,we=class{constructor(e=!1){this.detached=e,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this._warnOnRun=!0,this.__v_skip=!0,!e&&A&&(A.active?(this.parent=A,this.index=(A.scopes||=[]).push(this)-1):(this._active=!1,this._warnOnRun=!1))}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let e,t;if(this.scopes)for(e=0,t=this.scopes.length;e0&&--this._on===0){if(A===this)A=this.prevScope;else{let e=A;for(;e;){if(e.prevScope===this){e.prevScope=this.prevScope;break}e=e.prevScope}}this.prevScope=void 0}}stop(e){if(this._active){this._active=!1;let t,n;for(t=0,n=this.effects.length;t0)return;if(Ae){let e=Ae;for(Ae=void 0;e;){let t=e.next;e.next=void 0,e.flags&=-9,e=t}}let e;for(;ke;){let t=ke;for(ke=void 0;t;){let n=t.next;if(t.next=void 0,t.flags&=-9,t.flags&1)try{t.trigger()}catch(t){e||=t}t=n}}if(e)throw e}function Pe(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function Fe(e){let t,n=e.depsTail,r=n;for(;r;){let e=r.prevDep;r.version===-1?(r===n&&(n=e),Re(r),ze(r)):t=r,r.dep.activeLink=r.prevActiveLink,r.prevActiveLink=void 0,r=e}e.deps=t,e.depsTail=n}function Ie(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Le(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Le(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===Ge)||(e.globalVersion=Ge,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Ie(e))))return;e.flags|=2;let t=e.dep,n=j,r=Be;j=e,Be=!0;try{Pe(e);let n=e.fn(e._value);(t.version===0||E(n,e._value))&&(e.flags|=128,e._value=n,t.version++)}catch(e){throw t.version++,e}finally{j=n,Be=r,Fe(e),e.flags&=-3}}function Re(e,t=!1){let{dep:n,prevSub:r,nextSub:i}=e;if(r&&(r.nextSub=i,e.prevSub=void 0),i&&(i.prevSub=r,e.nextSub=void 0),n.subs===e&&(n.subs=r,!r&&n.computed)){n.computed.flags&=-5;for(let e=n.computed.deps;e;e=e.nextDep)Re(e,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function ze(e){let{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}var Be=!0,Ve=[];function He(){Ve.push(Be),Be=!1}function Ue(){let e=Ve.pop();Be=e===void 0||e}function We(e){let{cleanup:t}=e;if(e.cleanup=void 0,t){let e=j;j=void 0;try{t()}finally{j=e}}}var Ge=0,Ke=class{constructor(e,t){this.sub=e,this.dep=t,this.version=t.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}},qe=class{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(!j||!Be||j===this.computed)return;let t=this.activeLink;if(t===void 0||t.sub!==j)t=this.activeLink=new Ke(j,this),j.deps?(t.prevDep=j.depsTail,j.depsTail.nextDep=t,j.depsTail=t):j.deps=j.depsTail=t,Je(t);else if(t.version===-1&&(t.version=this.version,t.nextDep)){let e=t.nextDep;e.prevDep=t.prevDep,t.prevDep&&(t.prevDep.nextDep=e),t.prevDep=j.depsTail,t.nextDep=void 0,j.depsTail.nextDep=t,j.depsTail=t,j.deps===t&&(j.deps=e)}return t}trigger(e){this.version++,Ge++,this.notify(e)}notify(e){Me();try{for(let e=this.subs;e;e=e.prevSub)e.sub.notify()&&e.sub.dep.notify()}finally{Ne()}}};function Je(e){if(e.dep.sc++,e.sub.flags&4){let t=e.dep.computed;if(t&&!e.dep.subs){t.flags|=20;for(let e=t.deps;e;e=e.nextDep)Je(e)}let n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}var Ye=new WeakMap,Xe=Symbol(``),Ze=Symbol(``),Qe=Symbol(``);function M(e,t,n){if(Be&&j){let t=Ye.get(e);t||Ye.set(e,t=new Map);let r=t.get(n);r||(t.set(n,r=new qe),r.map=t,r.key=n),r.track()}}function $e(e,t,n,r,i,a){let o=Ye.get(e);if(!o){Ge++;return}let s=e=>{e&&e.trigger()};if(Me(),t===`clear`)o.forEach(s);else{let i=d(e),a=i&&C(n);if(i&&n===`length`){let e=Number(r);o.forEach((t,n)=>{(n===`length`||n===Qe||!_(n)&&n>=e)&&s(t)})}else switch((n!==void 0||o.has(void 0))&&s(o.get(n)),a&&s(o.get(Qe)),t){case`add`:i?a&&s(o.get(`length`)):(s(o.get(Xe)),f(e)&&s(o.get(Ze)));break;case`delete`:i||(s(o.get(Xe)),f(e)&&s(o.get(Ze)));break;case`set`:f(e)&&s(o.get(Xe));break}}Ne()}function et(e){let t=P(e);return t===e?t:(M(t,`iterate`,Qe),N(e)?t:t.map(Vt))}function tt(e){return M(e=P(e),`iterate`,Qe),e}function nt(e,t){return Rt(e)?Ht(Lt(e)?Vt(t):t):Vt(t)}var rt={__proto__:null,[Symbol.iterator](){return it(this,Symbol.iterator,e=>nt(this,e))},concat(...e){return et(this).concat(...e.map(e=>d(e)?et(e):e))},entries(){return it(this,`entries`,e=>(e[1]=nt(this,e[1]),e))},every(e,t){return ot(this,`every`,e,t,void 0,arguments)},filter(e,t){return ot(this,`filter`,e,t,e=>e.map(e=>nt(this,e)),arguments)},find(e,t){return ot(this,`find`,e,t,e=>nt(this,e),arguments)},findIndex(e,t){return ot(this,`findIndex`,e,t,void 0,arguments)},findLast(e,t){return ot(this,`findLast`,e,t,e=>nt(this,e),arguments)},findLastIndex(e,t){return ot(this,`findLastIndex`,e,t,void 0,arguments)},forEach(e,t){return ot(this,`forEach`,e,t,void 0,arguments)},includes(...e){return ct(this,`includes`,e)},indexOf(...e){return ct(this,`indexOf`,e)},join(e){return et(this).join(e)},lastIndexOf(...e){return ct(this,`lastIndexOf`,e)},map(e,t){return ot(this,`map`,e,t,void 0,arguments)},pop(){return lt(this,`pop`)},push(...e){return lt(this,`push`,e)},reduce(e,...t){return st(this,`reduce`,e,t)},reduceRight(e,...t){return st(this,`reduceRight`,e,t)},shift(){return lt(this,`shift`)},some(e,t){return ot(this,`some`,e,t,void 0,arguments)},splice(...e){return lt(this,`splice`,e)},toReversed(){return et(this).toReversed()},toSorted(e){return et(this).toSorted(e)},toSpliced(...e){return et(this).toSpliced(...e)},unshift(...e){return lt(this,`unshift`,e)},values(){return it(this,`values`,e=>nt(this,e))}};function it(e,t,n){let r=tt(e),i=r[t]();return r!==e&&!N(e)&&(i._next=i.next,i.next=()=>{let e=i._next();return e.done||(e.value=n(e.value)),e}),i}var at=Array.prototype;function ot(e,t,n,r,i,a){let o=tt(e),s=o!==e&&!N(e),c=o[t];if(c!==at[t]){let t=c.apply(e,a);return s?Vt(t):t}let l=n;o!==e&&(s?l=function(t,r){return n.call(this,nt(e,t),r,e)}:n.length>2&&(l=function(t,r){return n.call(this,t,r,e)}));let u=c.call(o,l,r);return s&&i?i(u):u}function st(e,t,n,r){let i=tt(e),a=i!==e&&!N(e),o=n,s=!1;i!==e&&(a?(s=r.length===0,o=function(t,r,i){return s&&(s=!1,t=nt(e,t)),n.call(this,t,nt(e,r),i,e)}):n.length>3&&(o=function(t,r,i){return n.call(this,t,r,i,e)}));let c=i[t](o,...r);return s?nt(e,c):c}function ct(e,t,n){let r=P(e);M(r,`iterate`,Qe);let i=r[t](...n);return(i===-1||i===!1)&&zt(n[0])?(n[0]=P(n[0]),r[t](...n)):i}function lt(e,t,n=[]){He(),Me();let r=P(e)[t].apply(e,n);return Ne(),Ue(),r}var ut=e(`__proto__,__v_isRef,__isVue`),dt=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!==`arguments`&&e!==`caller`).map(e=>Symbol[e]).filter(_));function ft(e){_(e)||(e=String(e));let t=P(this);return M(t,`has`,e),t.hasOwnProperty(e)}var pt=class{constructor(e=!1,t=!1){this._isReadonly=e,this._isShallow=t}get(e,t,n){if(t===`__v_skip`)return e.__v_skip;let r=this._isReadonly,i=this._isShallow;if(t===`__v_isReactive`)return!r;if(t===`__v_isReadonly`)return r;if(t===`__v_isShallow`)return i;if(t===`__v_raw`)return n===(r?i?jt:At:i?kt:Ot).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(n)?e:void 0;let a=d(e);if(!r){let e;if(a&&(e=rt[t]))return e;if(t===`hasOwnProperty`)return ft}let o=Reflect.get(e,t,F(e)?e:n);if((_(t)?dt.has(t):ut(t))||(r||M(e,`get`,t),i))return o;if(F(o)){let e=a&&C(t)?o:o.value;return r&&v(e)?Ft(e):e}return v(o)?r?Ft(o):Nt(o):o}},mt=class extends pt{constructor(e=!1){super(!1,e)}set(e,t,n,r){let i=e[t],a=d(e)&&C(t);if(!this._isShallow){let e=Rt(i);if(!N(n)&&!Rt(n)&&(i=P(i),n=P(n)),!a&&F(i)&&!F(n))return e||(i.value=n),!0}let o=a?Number(t)e,bt=e=>Reflect.getPrototypeOf(e);function xt(e,t,n){return function(...r){let i=this.__v_raw,a=P(i),o=f(a),c=e===`entries`||e===Symbol.iterator&&o,l=e===`keys`&&o,u=i[e](...r),d=n?yt:t?Ht:Vt;return!t&&M(a,`iterate`,l?Ze:Xe),s(Object.create(u),{next(){let{value:e,done:t}=u.next();return t?{value:e,done:t}:{value:c?[d(e[0]),d(e[1])]:d(e),done:t}}})}}function St(e){return function(...t){return e===`delete`?!1:e===`clear`?void 0:this}}function Ct(e,t){let n={get(n){let r=this.__v_raw,i=P(r),a=P(n);e||(E(n,a)&&M(i,`get`,n),M(i,`get`,a));let{has:o}=bt(i),s=t?yt:e?Ht:Vt;if(o.call(i,n))return s(r.get(n));if(o.call(i,a))return s(r.get(a));r!==i&&r.get(n)},get size(){let t=this.__v_raw;return!e&&M(P(t),`iterate`,Xe),t.size},has(t){let n=this.__v_raw,r=P(n),i=P(t);return e||(E(t,i)&&M(r,`has`,t),M(r,`has`,i)),t===i?n.has(t):n.has(t)||n.has(i)},forEach(n,r){let i=this,a=i.__v_raw,o=P(a),s=t?yt:e?Ht:Vt;return!e&&M(o,`iterate`,Xe),a.forEach((e,t)=>n.call(r,s(e),s(t),i))}};return s(n,e?{add:St(`add`),set:St(`set`),delete:St(`delete`),clear:St(`clear`)}:{add(e){let n=P(this),r=bt(n),i=P(e),a=!t&&!N(e)&&!Rt(e)?i:e;return r.has.call(n,a)||E(e,a)&&r.has.call(n,e)||E(i,a)&&r.has.call(n,i)||(n.add(a),$e(n,`add`,a,a)),this},set(e,n){!t&&!N(n)&&!Rt(n)&&(n=P(n));let r=P(this),{has:i,get:a}=bt(r),o=i.call(r,e);o||=(e=P(e),i.call(r,e));let s=a.call(r,e);return r.set(e,n),o?E(n,s)&&$e(r,`set`,e,n,s):$e(r,`add`,e,n),this},delete(e){let t=P(this),{has:n,get:r}=bt(t),i=n.call(t,e);i||=(e=P(e),n.call(t,e));let a=r?r.call(t,e):void 0,o=t.delete(e);return i&&$e(t,`delete`,e,void 0,a),o},clear(){let e=P(this),t=e.size!==0,n=e.clear();return t&&$e(e,`clear`,void 0,void 0,void 0),n}}),[`keys`,`values`,`entries`,Symbol.iterator].forEach(r=>{n[r]=xt(r,e,t)}),n}function wt(e,t){let n=Ct(e,t);return(t,r,i)=>r===`__v_isReactive`?!e:r===`__v_isReadonly`?e:r===`__v_raw`?t:Reflect.get(u(n,r)&&r in t?n:t,r,i)}var Tt={get:wt(!1,!1)},Et={get:wt(!1,!0)},Dt={get:wt(!0,!1)},Ot=new WeakMap,kt=new WeakMap,At=new WeakMap,jt=new WeakMap;function Mt(e){switch(e){case`Object`:case`Array`:return 1;case`Map`:case`Set`:case`WeakMap`:case`WeakSet`:return 2;default:return 0}}function Nt(e){return Rt(e)?e:It(e,!1,gt,Tt,Ot)}function Pt(e){return It(e,!1,vt,Et,kt)}function Ft(e){return It(e,!0,_t,Dt,At)}function It(e,t,n,r,i){if(!v(e)||e.__v_raw&&!(t&&e.__v_isReactive)||e.__v_skip||!Object.isExtensible(e))return e;let a=i.get(e);if(a)return a;let o=Mt(ee(e));if(o===0)return e;let s=new Proxy(e,o===2?r:n);return i.set(e,s),s}function Lt(e){return Rt(e)?Lt(e.__v_raw):!!(e&&e.__v_isReactive)}function Rt(e){return!!(e&&e.__v_isReadonly)}function N(e){return!!(e&&e.__v_isShallow)}function zt(e){return e?!!e.__v_raw:!1}function P(e){let t=e&&e.__v_raw;return t?P(t):e}function Bt(e){return!u(e,`__v_skip`)&&Object.isExtensible(e)&&D(e,`__v_skip`,!0),e}var Vt=e=>v(e)?Nt(e):e,Ht=e=>v(e)?Ft(e):e;function F(e){return e?e.__v_isRef===!0:!1}function I(e){return Ut(e,!1)}function Ut(e,t){return F(e)?e:new Wt(e,t)}var Wt=class{constructor(e,t){this.dep=new qe,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=t?e:P(e),this._value=t?e:Vt(e),this.__v_isShallow=t}get value(){return this.dep.track(),this._value}set value(e){let t=this._rawValue,n=this.__v_isShallow||N(e)||Rt(e);e=n?e:P(e),E(e,t)&&(this._rawValue=e,this._value=n?e:Vt(e),this.dep.trigger())}};function Gt(e){return F(e)?e.value:e}var Kt={get:(e,t,n)=>t===`__v_raw`?e:Gt(Reflect.get(e,t,n)),set:(e,t,n,r)=>{let i=e[t];return F(i)&&!F(n)?(i.value=n,!0):Reflect.set(e,t,n,r)}};function qt(e){return Lt(e)?e:new Proxy(e,Kt)}var Jt=class{constructor(e,t,n){this.fn=e,this.setter=t,this._value=void 0,this.dep=new qe(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=Ge-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!t,this.isSSR=n}notify(){if(this.flags|=16,!(this.flags&8)&&j!==this)return je(this,!0),!0}get value(){let e=this.dep.track();return Le(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}};function Yt(e,t,n=!1){let r,i;return h(e)?r=e:(r=e.get,i=e.set),new Jt(r,i,n)}var Xt={},Zt=new WeakMap,Qt=void 0;function $t(e,t=!1,n=Qt){if(n){let t=Zt.get(n);t||Zt.set(n,t=[]),t.push(e)}}function en(e,n,i=t){let{immediate:a,deep:o,once:s,scheduler:l,augmentJob:u,call:f}=i,p=e=>o?e:N(e)||o===!1||o===0?tn(e,1):tn(e),m,g,_,v,y=!1,b=!1;if(F(e)?(g=()=>e.value,y=N(e)):Lt(e)?(g=()=>p(e),y=!0):d(e)?(b=!0,y=e.some(e=>Lt(e)||N(e)),g=()=>e.map(e=>{if(F(e))return e.value;if(Lt(e))return p(e);if(h(e))return f?f(e,2):e()})):g=h(e)?n?f?()=>f(e,2):e:()=>{if(_){He();try{_()}finally{Ue()}}let t=Qt;Qt=m;try{return f?f(e,3,[v]):e(v)}finally{Qt=t}}:r,n&&o){let e=g,t=o===!0?1/0:o;g=()=>tn(e(),t)}let x=Te(),ee=()=>{m.stop(),x&&x.active&&c(x.effects,m)};if(s&&n){let e=n;n=(...t)=>{let n=e(...t);return ee(),n}}let S=b?Array(e.length).fill(Xt):Xt,C=e=>{if(!(!(m.flags&1)||!m.dirty&&!e))if(n){let t=m.run();if(e||o||y||(b?t.some((e,t)=>E(e,S[t])):E(t,S))){_&&_();let e=Qt;Qt=m;try{let e=[t,S===Xt?void 0:b&&S[0]===Xt?[]:S,v];S=t,f?f(n,3,e):n(...e)}finally{Qt=e}}}else m.run()};return u&&u(C),m=new De(g),m.scheduler=l?()=>l(C,!1):C,v=e=>$t(e,!1,m),_=m.onStop=()=>{let e=Zt.get(m);if(e){if(f)f(e,4);else for(let t of e)t();Zt.delete(m)}},n?a?C(!0):S=m.run():l?l(C.bind(null,!0),!0):m.run(),ee.pause=m.pause.bind(m),ee.resume=m.resume.bind(m),ee.stop=ee,ee}function tn(e,t=1/0,n){if(t<=0||!v(e)||e.__v_skip||(n||=new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,F(e))tn(e.value,t,n);else if(d(e))for(let r=0;r{tn(e,t,n)});else if(S(e)){for(let r in e)tn(e[r],t,n);for(let r of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,r)&&tn(e[r],t,n)}return e}function nn(e,t,n,r){try{return r?e(...r):e()}catch(e){rn(e,t,n)}}function L(e,t,n,r){if(h(e)){let i=nn(e,t,n,r);return i&&y(i)&&i.catch(e=>{rn(e,t,n)}),i}if(d(e)){let i=[];for(let a=0;a>>1,i=R[r],a=yn(i);a=yn(n)?R.push(e):R.splice(pn(t),0,e),e.flags|=1,hn()}}function hn(){dn||=un.then(bn)}function gn(e){d(e)?sn.push(...e):cn&&e.id===-1?cn.splice(ln+1,0,e):e.flags&1||(sn.push(e),e.flags|=1),hn()}function _n(e,t,n=on+1){for(;nyn(e)-yn(t));if(sn.length=0,cn){cn.push(...e);return}for(cn=e,ln=0;lne.id==null?e.flags&2?-1:1/0:e.id;function bn(e){try{for(on=0;on{r._d&&Ti(-1);let i=Cn(t),a;try{a=e(...n)}finally{Cn(i),r._d&&Ti(1)}return a};return r._n=!0,r._c=!0,r._d=!0,r}function Tn(e,t,n,r){let i=e.dirs,a=t&&t.dirs;for(let o=0;o1)return n&&h(t)?t.call(r&&r.proxy):t}}var On=Symbol.for(`v-scx`),kn=()=>Dn(On);function An(e,t,n){return jn(e,t,n)}function jn(e,n,i=t){let{immediate:a,deep:o,flush:c,once:l}=i,u=s({},i),d=n&&a||!n&&c!==`post`,f;if(Yi){if(c===`sync`){let e=kn();f=e.__watcherHandles||=[]}else if(!d){let e=()=>{};return e.stop=r,e.resume=r,e.pause=r,e}}let p=X;u.call=(e,t,n)=>L(e,p,t,n);let m=!1;c===`post`?u.scheduler=e=>{V(e,p&&p.suspense)}:c!==`sync`&&(m=!0,u.scheduler=(e,t)=>{t?e():mn(e)}),u.augmentJob=e=>{n&&(e.flags|=4),m&&(e.flags|=2,p&&(e.id=p.uid,e.i=p))};let h=en(e,n,u);return Yi&&(f?f.push(h):d&&h()),h}function Mn(e,t,n){let r=this.proxy,i=g(e)?e.includes(`.`)?Nn(r,e):()=>r[e]:e.bind(r,r),a;h(t)?a=t:(a=t.handler,n=t);let o=Ki(this),s=jn(i,a.bind(r),n);return o(),s}function Nn(e,t){let n=t.split(`.`);return()=>{let t=e;for(let e=0;ee.__isTeleport,In=Symbol(`_leaveCb`);function Ln(e,t){e.shapeFlag&6&&e.component?(e.transition=t,Ln(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 Rn(e){e.ids=[e.ids[0]+e.ids[2]+++`-`,0,0]}function zn(e,t){let n;return!!((n=Object.getOwnPropertyDescriptor(e,t))&&!n.configurable)}var Bn=new WeakMap;function Vn(e,n,r,a,o=!1){if(d(e)){e.forEach((e,t)=>Vn(e,n&&(d(n)?n[t]:n),r,a,o));return}if(Un(a)&&!o){a.shapeFlag&512&&a.type.__asyncResolved&&a.component.subTree.component&&Vn(e,n,r,a.component.subTree);return}let s=a.shapeFlag&4?ia(a.component):a.el,l=o?null:s,{i:f,r:p}=e,m=n&&n.r,_=f.refs===t?f.refs={}:f.refs,v=f.setupState,y=P(v),b=v===t?i:e=>!zn(_,e)&&u(y,e),x=(e,t)=>!(t&&zn(_,t));if(m!=null&&m!==p){if(Hn(n),g(m))_[m]=null,b(m)&&(v[m]=null);else if(F(m)){let e=n;x(m,e.k)&&(m.value=null),e.k&&(_[e.k]=null)}}if(h(p)){He();try{nn(p,f,12,[l,_])}finally{Ue()}}else{let t=g(p),n=F(p);if(t||n){let i=()=>{if(e.f){let n=t?b(p)?v[p]:_[p]:x(p)||!e.k?p.value:_[e.k];if(o)d(n)&&c(n,s);else if(d(n))n.includes(s)||n.push(s);else if(t)_[p]=[s],b(p)&&(v[p]=_[p]);else{let t=[s];x(p,e.k)&&(p.value=t),e.k&&(_[e.k]=t)}}else t?(_[p]=l,b(p)&&(v[p]=l)):n&&(x(p,e.k)&&(p.value=l),e.k&&(_[e.k]=l))};if(l){let t=()=>{i(),Bn.delete(e)};t.id=-1,Bn.set(e,t),V(t,r)}else Hn(e),i()}}}function Hn(e){let t=Bn.get(e);t&&(t.flags|=8,Bn.delete(e))}ue().requestIdleCallback,ue().cancelIdleCallback;var Un=e=>!!e.type.__asyncLoader,Wn=e=>e.type.__isKeepAlive;function Gn(e,t){qn(e,`a`,t)}function Kn(e,t){qn(e,`da`,t)}function qn(e,t,n=X){let r=e.__wdc||=()=>{let t=n;for(;t;){if(t.isDeactivated)return;t=t.parent}return e()};if(Yn(t,r,n),n){let e=n.parent;for(;e&&e.parent;)Wn(e.parent.vnode)&&Jn(r,t,n,e),e=e.parent}}function Jn(e,t,n,r){let i=Yn(t,e,r,!0);nr(()=>{c(r[t],i)},n)}function Yn(e,t,n=X,r=!1){if(n){let i=n[e]||(n[e]=[]),a=t.__weh||=(...r)=>{He();let i=Ki(n),a=L(t,n,e,r);return i(),Ue(),a};return r?i.unshift(a):i.push(a),a}}var Xn=e=>(t,n=X)=>{(!Yi||e===`sp`)&&Yn(e,(...e)=>t(...e),n)},Zn=Xn(`bm`),Qn=Xn(`m`),$n=Xn(`bu`),er=Xn(`u`),tr=Xn(`bum`),nr=Xn(`um`),rr=Xn(`sp`),ir=Xn(`rtg`),ar=Xn(`rtc`);function or(e,t=X){Yn(`ec`,e,t)}var sr=Symbol.for(`v-ndc`);function z(e,t,n,r){let i,a=n&&n[r],o=d(e);if(o||g(e)){let n=o&&Lt(e),r=!1,s=!1;n&&(r=!N(e),s=Rt(e),e=tt(e)),i=Array(e.length);for(let n=0,o=e.length;nt(e,n,void 0,a&&a[n]));else{let n=Object.keys(e);i=Array(n.length);for(let r=0,o=n.length;re?Ji(e)?ia(e):cr(e.parent):null,lr=s(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=>cr(e.parent),$root:e=>cr(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>vr(e),$forceUpdate:e=>e.f||=()=>{mn(e.update)},$nextTick:e=>e.n||=fn.bind(e.proxy),$watch:e=>Mn.bind(e)}),ur=(e,n)=>e!==t&&!e.__isScriptSetup&&u(e,n),dr={get({_:e},n){if(n===`__v_skip`)return!0;let{ctx:r,setupState:i,data:a,props:o,accessCache:s,type:c,appContext:l}=e;if(n[0]!==`$`){let e=s[n];if(e!==void 0)switch(e){case 1:return i[n];case 2:return a[n];case 4:return r[n];case 3:return o[n]}else if(ur(i,n))return s[n]=1,i[n];else if(a!==t&&u(a,n))return s[n]=2,a[n];else if(u(o,n))return s[n]=3,o[n];else if(r!==t&&u(r,n))return s[n]=4,r[n];else pr&&(s[n]=0)}let d=lr[n],f,p;if(d)return n===`$attrs`&&M(e.attrs,`get`,``),d(e);if((f=c.__cssModules)&&(f=f[n]))return f;if(r!==t&&u(r,n))return s[n]=4,r[n];if(p=l.config.globalProperties,u(p,n))return p[n]},set({_:e},n,r){let{data:i,setupState:a,ctx:o}=e;return ur(a,n)?(a[n]=r,!0):i!==t&&u(i,n)?(i[n]=r,!0):u(e.props,n)||n[0]===`$`&&n.slice(1)in e?!1:(o[n]=r,!0)},has({_:{data:e,setupState:n,accessCache:r,ctx:i,appContext:a,props:o,type:s}},c){let l;return!!(r[c]||e!==t&&c[0]!==`$`&&u(e,c)||ur(n,c)||u(o,c)||u(i,c)||u(lr,c)||u(a.config.globalProperties,c)||(l=s.__cssModules)&&l[c])},defineProperty(e,t,n){return n.get==null?u(n,`value`)&&this.set(e,t,n.value,null):e._.accessCache[t]=0,Reflect.defineProperty(e,t,n)}};function fr(e){return d(e)?e.reduce((e,t)=>(e[t]=null,e),{}):e}var pr=!0;function mr(e){let t=vr(e),n=e.proxy,i=e.ctx;pr=!1,t.beforeCreate&&gr(t.beforeCreate,e,`bc`);let{data:a,computed:o,methods:s,watch:c,provide:l,inject:u,created:f,beforeMount:p,mounted:m,beforeUpdate:g,updated:_,activated:y,deactivated:b,beforeDestroy:x,beforeUnmount:ee,destroyed:S,unmounted:C,render:te,renderTracked:ne,renderTriggered:re,errorCaptured:w,serverPrefetch:ie,expose:T,inheritAttrs:ae,components:oe,directives:E,filters:se}=t;if(u&&hr(u,i,null),s)for(let e in s){let t=s[e];h(t)&&(i[e]=t.bind(n))}if(a){let t=a.call(n,n);v(t)&&(e.data=Nt(t))}if(pr=!0,o)for(let e in o){let t=o[e],a=oa({get:h(t)?t.bind(n,n):h(t.get)?t.get.bind(n,n):r,set:!h(t)&&h(t.set)?t.set.bind(n):r});Object.defineProperty(i,e,{enumerable:!0,configurable:!0,get:()=>a.value,set:e=>a.value=e})}if(c)for(let e in c)_r(c[e],i,n,e);if(l){let e=h(l)?l.call(n):l;Reflect.ownKeys(e).forEach(t=>{En(t,e[t])})}f&&gr(f,e,`c`);function D(e,t){d(t)?t.forEach(t=>e(t.bind(n))):t&&e(t.bind(n))}if(D(Zn,p),D(Qn,m),D($n,g),D(er,_),D(Gn,y),D(Kn,b),D(or,w),D(ar,ne),D(ir,re),D(tr,ee),D(nr,C),D(rr,ie),d(T))if(T.length){let t=e.exposed||={};T.forEach(e=>{Object.defineProperty(t,e,{get:()=>n[e],set:t=>n[e]=t,enumerable:!0})})}else e.exposed||={};te&&e.render===r&&(e.render=te),ae!=null&&(e.inheritAttrs=ae),oe&&(e.components=oe),E&&(e.directives=E),ie&&Rn(e)}function hr(e,t,n=r){d(e)&&(e=Cr(e));for(let n in e){let r=e[n],i;i=v(r)?`default`in r?Dn(r.from||n,r.default,!0):Dn(r.from||n):Dn(r),F(i)?Object.defineProperty(t,n,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e}):t[n]=i}}function gr(e,t,n){L(d(e)?e.map(e=>e.bind(t.proxy)):e.bind(t.proxy),t,n)}function _r(e,t,n,r){let i=r.includes(`.`)?Nn(n,r):()=>n[r];if(g(e)){let n=t[e];h(n)&&An(i,n)}else if(h(e))An(i,e.bind(n));else if(v(e))if(d(e))e.forEach(e=>_r(e,t,n,r));else{let r=h(e.handler)?e.handler.bind(n):t[e.handler];h(r)&&An(i,r,e)}}function vr(e){let t=e.type,{mixins:n,extends:r}=t,{mixins:i,optionsCache:a,config:{optionMergeStrategies:o}}=e.appContext,s=a.get(t),c;return s?c=s:!i.length&&!n&&!r?c=t:(c={},i.length&&i.forEach(e=>yr(c,e,o,!0)),yr(c,t,o)),v(t)&&a.set(t,c),c}function yr(e,t,n,r=!1){let{mixins:i,extends:a}=t;a&&yr(e,a,n,!0),i&&i.forEach(t=>yr(e,t,n,!0));for(let i in t)if(!(r&&i===`expose`)){let r=br[i]||n&&n[i];e[i]=r?r(e[i],t[i]):t[i]}return e}var br={data:xr,props:Tr,emits:Tr,methods:wr,computed:wr,beforeCreate:B,created:B,beforeMount:B,mounted:B,beforeUpdate:B,updated:B,beforeDestroy:B,beforeUnmount:B,destroyed:B,unmounted:B,activated:B,deactivated:B,errorCaptured:B,serverPrefetch:B,components:wr,directives:wr,watch:Er,provide:xr,inject:Sr};function xr(e,t){return t?e?function(){return s(h(e)?e.call(this,this):e,h(t)?t.call(this,this):t)}:t:e}function Sr(e,t){return wr(Cr(e),Cr(t))}function Cr(e){if(d(e)){let t={};for(let n=0;nt===`modelValue`||t===`model-value`?e.modelModifiers:e[`${t}Modifiers`]||e[`${w(t)}Modifiers`]||e[`${T(t)}Modifiers`];function Mr(e,n,...r){if(e.isUnmounted)return;let i=e.vnode.props||t,a=r,o=n.startsWith(`update:`),s=o&&jr(i,n.slice(7));s&&(s.trim&&(a=r.map(e=>g(e)?e.trim():e)),s.number&&(a=r.map(ce)));let c,l=i[c=oe(n)]||i[c=oe(w(n))];!l&&o&&(l=i[c=oe(T(n))]),l&&L(l,e,6,a);let u=i[c+`Once`];if(u){if(!e.emitted)e.emitted={};else if(e.emitted[c])return;e.emitted[c]=!0,L(u,e,6,a)}}var Nr=new WeakMap;function Pr(e,t,n=!1){let r=n?Nr:t.emitsCache,i=r.get(e);if(i!==void 0)return i;let a=e.emits,o={},c=!1;if(!h(e)){let r=e=>{let n=Pr(e,t,!0);n&&(c=!0,s(o,n))};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}return!a&&!c?(v(e)&&r.set(e,null),null):(d(a)?a.forEach(e=>o[e]=null):s(o,a),v(e)&&r.set(e,o),o)}function Fr(e,t){return!e||!a(t)?!1:(t=t.slice(2),t=t===`Once`?t:t.replace(/Once$/,``),u(e,t[0].toLowerCase()+t.slice(1))||u(e,T(t))||u(e,t))}function Ir(e){let{type:t,vnode:n,proxy:r,withProxy:i,propsOptions:[a],slots:s,attrs:c,emit:l,render:u,renderCache:d,props:f,data:p,setupState:m,ctx:h,inheritAttrs:g}=e,_=Cn(e),v,y;try{if(n.shapeFlag&4){let e=i||r,t=e;v=Fi(u.call(t,e,d,f,m,p,h)),y=c}else{let e=t;v=Fi(e.length>1?e(f,{attrs:c,slots:s,emit:l}):e(f,null)),y=t.props?c:Lr(c)}}catch(t){Si.length=0,rn(t,e,1),v=J(bi)}let b=v;if(y&&g!==!1){let e=Object.keys(y),{shapeFlag:t}=b;e.length&&t&7&&(a&&e.some(o)&&(y=Rr(y,a)),b=Ni(b,y,!1,!0))}return n.dirs&&(b=Ni(b,null,!1,!0),b.dirs=b.dirs?b.dirs.concat(n.dirs):n.dirs),n.transition&&Ln(b,n.transition),v=b,Cn(_),v}var Lr=e=>{let t;for(let n in e)(n===`class`||n===`style`||a(n))&&((t||={})[n]=e[n]);return t},Rr=(e,t)=>{let n={};for(let r in e)(!o(r)||!(r.slice(9)in t))&&(n[r]=e[r]);return n};function zr(e,t,n){let{props:r,children:i,component:a}=e,{props:o,children:s,patchFlag:c}=t,l=a.emitsOptions;if(t.dirs||t.transition)return!0;if(n&&c>=0){if(c&1024)return!0;if(c&16)return r?Br(r,o,l):!!o;if(c&8){let e=t.dynamicProps;for(let t=0;tObject.create(Ur),Gr=e=>Object.getPrototypeOf(e)===Ur;function Kr(e,t,n,r=!1){let i={},a=Wr();e.propsDefaults=Object.create(null),Jr(e,t,i,a);for(let t in e.propsOptions[0])t in i||(i[t]=void 0);n?e.props=r?i:Pt(i):e.type.props?e.props=i:e.props=a,e.attrs=a}function qr(e,t,n,r){let{props:i,attrs:a,vnode:{patchFlag:o}}=e,s=P(i),[c]=e.propsOptions,l=!1;if((r||o>0)&&!(o&16)){if(o&8){let n=e.vnode.dynamicProps;for(let r=0;r{p=!0;let[t,n]=Zr(e,r,!0);s(l,t),n&&f.push(...n)};!i&&r.mixins.length&&r.mixins.forEach(t),e.extends&&t(e.extends),e.mixins&&e.mixins.forEach(t)}if(!c&&!p)return v(e)&&a.set(e,n),n;if(d(c))for(let e=0;ee===`_`||e===`_ctx`||e===`$stable`,ei=e=>d(e)?e.map(Fi):[Fi(e)],ti=(e,t,n)=>{if(t._n)return t;let r=wn((...e)=>ei(t(...e)),n);return r._c=!1,r},ni=(e,t,n)=>{let r=e._ctx;for(let n in e){if($r(n))continue;let i=e[n];if(h(i))t[n]=ti(n,i,r);else if(i!=null){let e=ei(i);t[n]=()=>e}}},ri=(e,t)=>{let n=ei(t);e.slots.default=()=>n},ii=(e,t,n)=>{for(let r in t)(n||!$r(r))&&(e[r]=t[r])},ai=(e,t,n)=>{let r=e.slots=Wr();if(e.vnode.shapeFlag&32){let e=t._;e?(ii(r,t,n),n&&D(r,`_`,e,!0)):ni(t,r)}else t&&ri(e,t)},oi=(e,n,r)=>{let{vnode:i,slots:a}=e,o=!0,s=t;if(i.shapeFlag&32){let e=n._;e?r&&e===1?o=!1:ii(a,n,r):(o=!n.$stable,ni(n,a)),s=n}else n&&(ri(e,n),s={default:1});if(o)for(let e in a)!$r(e)&&s[e]==null&&delete a[e]},V=vi;function si(e){return ci(e)}function ci(e,i){let a=ue();a.__VUE__=!0;let{insert:o,remove:s,patchProp:c,createElement:l,createText:u,createComment:d,setText:f,setElementText:p,parentNode:m,nextSibling:h,setScopeId:g=r,insertStaticContent:_}=e,v=(e,t,n,r=null,i=null,a=null,o=void 0,s=null,c=!!t.dynamicChildren)=>{if(e===t)return;e&&!Oi(e,t)&&(r=be(e),O(e,i,a,!0),e=null),t.patchFlag===-2&&(c=!1,t.dynamicChildren=null);let{type:l,ref:u,shapeFlag:d}=t;switch(l){case yi:y(e,t,n,r);break;case bi:b(e,t,n,r);break;case xi:e??x(t,n,r,o);break;case H:oe(e,t,n,r,i,a,o,s,c);break;default:d&1?C(e,t,n,r,i,a,o,s,c):d&6?E(e,t,n,r,i,a,o,s,c):(d&64||d&128)&&l.process(e,t,n,r,i,a,o,s,c,Se)}u!=null&&i?Vn(u,e&&e.ref,a,t||e,!t):u==null&&e&&e.ref!=null&&Vn(e.ref,null,a,e,!0)},y=(e,t,n,r)=>{if(e==null)o(t.el=u(t.children),n,r);else{let n=t.el=e.el;t.children!==e.children&&f(n,t.children)}},b=(e,t,n,r)=>{e==null?o(t.el=d(t.children||``),n,r):t.el=e.el},x=(e,t,n,r)=>{[e.el,e.anchor]=_(e.children,t,n,r,e.el,e.anchor)},ee=({el:e,anchor:t},n,r)=>{let i;for(;e&&e!==t;)i=h(e),o(e,n,r),e=i;o(t,n,r)},S=({el:e,anchor:t})=>{let n;for(;e&&e!==t;)n=h(e),s(e),e=n;s(t)},C=(e,t,n,r,i,a,o,s,c)=>{if(t.type===`svg`?o=`svg`:t.type===`math`&&(o=`mathml`),e==null)ne(t,n,r,i,a,o,s,c);else{let n=e.el&&e.el._isVueCE?e.el:null;try{n&&n._beginPatch(),ie(e,t,i,a,o,s,c)}finally{n&&n._endPatch()}}},ne=(e,t,n,r,i,a,s,u)=>{let d,f,{props:m,shapeFlag:h,transition:g,dirs:_}=e;if(d=e.el=l(e.type,a,m&&m.is,m),h&8?p(d,e.children):h&16&&w(e.children,d,null,r,i,li(e,a),s,u),_&&Tn(e,null,r,`created`),re(d,e,e.scopeId,s,r),m){for(let e in m)e!==`value`&&!te(e)&&c(d,e,null,m[e],a,r);`value`in m&&c(d,`value`,null,m.value,a),(f=m.onVnodeBeforeMount)&&zi(f,r,e)}_&&Tn(e,null,r,`beforeMount`);let v=di(i,g);v&&g.beforeEnter(d),o(d,t,n),((f=m&&m.onVnodeMounted)||v||_)&&V(()=>{try{f&&zi(f,r,e),v&&g.enter(d),_&&Tn(e,null,r,`mounted`)}finally{}},i)},re=(e,t,n,r,i)=>{if(n&&g(e,n),r)for(let t=0;t{for(let l=c;l{let l=n.el=e.el,{patchFlag:u,dynamicChildren:d,dirs:f}=n;u|=e.patchFlag&16;let m=e.props||t,h=n.props||t,g;if(r&&ui(r,!1),(g=h.onVnodeBeforeUpdate)&&zi(g,r,n,e),f&&Tn(n,e,r,`beforeUpdate`),r&&ui(r,!0),d&&(!e.dynamicChildren||e.dynamicChildren.length!==d.length)&&(u=0,s=!1,d=null),(m.innerHTML&&h.innerHTML==null||m.textContent&&h.textContent==null)&&p(l,``),d?T(e.dynamicChildren,d,l,r,i,li(n,a),o):s||fe(e,n,l,null,r,i,li(n,a),o,!1),u>0){if(u&16)ae(l,m,h,r,a);else if(u&2&&m.class!==h.class&&c(l,`class`,null,h.class,a),u&4&&c(l,`style`,m.style,h.style,a),u&8){let e=n.dynamicProps;for(let t=0;t{g&&zi(g,r,n,e),f&&Tn(n,e,r,`updated`)},i)},T=(e,t,n,r,i,a,o)=>{for(let s=0;s{if(n!==r){if(n!==t)for(let t in n)!te(t)&&!(t in r)&&c(e,t,n[t],null,a,i);for(let t in r){if(te(t))continue;let o=r[t],s=n[t];o!==s&&t!==`value`&&c(e,t,s,o,a,i)}`value`in r&&c(e,`value`,n.value,r.value,a)}},oe=(e,t,n,r,i,a,s,c,l)=>{let d=t.el=e?e.el:u(``),f=t.anchor=e?e.anchor:u(``),{patchFlag:p,dynamicChildren:m,slotScopeIds:h}=t;h&&(c=c?c.concat(h):h),e==null?(o(d,n,r),o(f,n,r),w(t.children||[],n,f,i,a,s,c,l)):p>0&&p&64&&m&&e.dynamicChildren&&e.dynamicChildren.length===m.length?(T(e.dynamicChildren,m,n,i,a,s,c),(t.key!=null||i&&t===i.subTree)&&fi(e,t,!0)):fe(e,t,n,f,i,a,s,c,l)},E=(e,t,n,r,i,a,o,s,c)=>{t.slotScopeIds=s,e==null?t.shapeFlag&512?i.ctx.activate(t,n,r,o,c):D(t,n,r,i,a,o,c):ce(e,t,c)},D=(e,t,n,r,i,a,o)=>{let s=e.component=Hi(e,r,i);if(Wn(e)&&(s.ctx.renderer=Se),Xi(s,!1,o),s.asyncDep){if(i&&i.registerDep(s,le,o),!e.el){let r=s.subTree=J(bi);b(null,r,t,n),e.placeholder=r.el}}else le(s,e,t,n,i,a,o)},ce=(e,t,n)=>{let r=t.component=e.component;if(zr(e,t,n))if(r.asyncDep&&!r.asyncResolved){de(r,t,n);return}else r.next=t,r.update();else t.el=e.el,r.vnode=t},le=(e,t,n,r,i,a,o)=>{let s=()=>{if(e.isMounted){let{next:t,bu:n,u:r,parent:s,vnode:c}=e;{let n=mi(e);if(n){t&&(t.el=c.el,de(e,t,o)),n.asyncDep.then(()=>{V(()=>{e.isUnmounted||l()},i)});return}}let u=t,d;ui(e,!1),t?(t.el=c.el,de(e,t,o)):t=c,n&&se(n),(d=t.props&&t.props.onVnodeBeforeUpdate)&&zi(d,s,t,c),ui(e,!0);let f=Ir(e),p=e.subTree;e.subTree=f,v(p,f,m(p.el),be(p),e,i,a),t.el=f.el,u===null&&Hr(e,f.el),r&&V(r,i),(d=t.props&&t.props.onVnodeUpdated)&&V(()=>zi(d,s,t,c),i)}else{let o,{el:s,props:c}=t,{bm:l,m:u,parent:d,root:f,type:p}=e,m=Un(t);if(ui(e,!1),l&&se(l),!m&&(o=c&&c.onVnodeBeforeMount)&&zi(o,d,t),ui(e,!0),s&&A){let t=()=>{e.subTree=Ir(e),A(s,e.subTree,e,i,null)};m&&p.__asyncHydrate?p.__asyncHydrate(s,e,t):t()}else{f.ce&&f.ce._hasShadowRoot()&&f.ce._injectChildStyle(p,e.parent?e.parent.type:void 0);let o=e.subTree=Ir(e);v(null,o,n,r,e,i,a),t.el=o.el}if(u&&V(u,i),!m&&(o=c&&c.onVnodeMounted)){let e=t;V(()=>zi(o,d,e),i)}(t.shapeFlag&256||d&&Un(d.vnode)&&d.vnode.shapeFlag&256)&&e.a&&V(e.a,i),e.isMounted=!0,t=n=r=null}};e.scope.on();let c=e.effect=new De(s);e.scope.off();let l=e.update=c.run.bind(c),u=e.job=c.runIfDirty.bind(c);u.i=e,u.id=e.uid,c.scheduler=()=>mn(u),ui(e,!0),l()},de=(e,t,n)=>{t.component=e;let r=e.vnode.props;e.vnode=t,e.next=null,qr(e,t.props,r,n),oi(e,t.children,n),He(),_n(e),Ue()},fe=(e,t,n,r,i,a,o,s,c=!1)=>{let l=e&&e.children,u=e?e.shapeFlag:0,d=t.children,{patchFlag:f,shapeFlag:m}=t;if(f>0){if(f&128){me(l,d,n,r,i,a,o,s,c);return}else if(f&256){pe(l,d,n,r,i,a,o,s,c);return}}m&8?(u&16&&ye(l,i,a),d!==l&&p(n,d)):u&16?m&16?me(l,d,n,r,i,a,o,s,c):ye(l,i,a,!0):(u&8&&p(n,``),m&16&&w(d,n,r,i,a,o,s,c))},pe=(e,t,r,i,a,o,s,c,l)=>{e||=n,t||=n;let u=e.length,d=t.length,f=Math.min(u,d),p;for(p=0;pd?ye(e,a,o,!0,!1,f):w(t,r,i,a,o,s,c,l,f)},me=(e,t,r,i,a,o,s,c,l)=>{let u=0,d=t.length,f=e.length-1,p=d-1;for(;u<=f&&u<=p;){let n=e[u],i=t[u]=l?Ii(t[u]):Fi(t[u]);if(Oi(n,i))v(n,i,r,null,a,o,s,c,l);else break;u++}for(;u<=f&&u<=p;){let n=e[f],i=t[p]=l?Ii(t[p]):Fi(t[p]);if(Oi(n,i))v(n,i,r,null,a,o,s,c,l);else break;f--,p--}if(u>f){if(u<=p){let e=p+1,n=ep)for(;u<=f;)O(e[u],a,o,!0),u++;else{let m=u,h=u,g=new Map;for(u=h;u<=p;u++){let e=t[u]=l?Ii(t[u]):Fi(t[u]);e.key!=null&&g.set(e.key,u)}let _,y=0,b=p-h+1,x=!1,ee=0,S=Array(b);for(u=0;u=b){O(n,a,o,!0);continue}let i;if(n.key!=null)i=g.get(n.key);else for(_=h;_<=p;_++)if(S[_-h]===0&&Oi(n,t[_])){i=_;break}i===void 0?O(n,a,o,!0):(S[i-h]=u+1,i>=ee?ee=i:x=!0,v(n,t[i],r,null,a,o,s,c,l),y++)}let C=x?pi(S):n;for(_=C.length-1,u=b-1;u>=0;u--){let e=h+u,n=t[e],f=t[e+1],p=e+1{let{el:a,type:c,transition:l,children:u,shapeFlag:d}=e;if(d&6){he(e.component.subTree,t,n,r);return}if(d&128){e.suspense.move(t,n,r);return}if(d&64){c.move(e,t,n,Se);return}if(c===H){o(a,t,n);for(let e=0;el.enter(a),i));else{let{leave:r,delayLeave:i,afterLeave:c}=l,u=()=>{e.ctx.isUnmounted?s(a):o(a,t,n)},d=()=>{let e=a._isLeaving||!!a[In];a._isLeaving&&a[In](!0),l.persisted&&!e?u():r(a,()=>{u(),c&&c()})};i?i(a,u,d):d()}else o(a,t,n)},O=(e,t,n,r=!1,i=!1)=>{let{type:a,props:o,ref:s,children:c,dynamicChildren:l,shapeFlag:u,patchFlag:d,dirs:f,cacheIndex:p,memo:m}=e;if(d===-2&&(i=!1),s!=null&&(He(),Vn(s,null,n,e,!0),Ue()),p!=null&&(t.renderCache[p]=void 0),u&256){t.ctx.deactivate(e);return}let h=u&1&&f,g=!Un(e),_;if(g&&(_=o&&o.onVnodeBeforeUnmount)&&zi(_,t,e),u&6)ve(e.component,n,r);else{if(u&128){e.suspense.unmount(n,r);return}h&&Tn(e,null,t,`beforeUnmount`),u&64?e.type.remove(e,t,n,Se,r):l&&!l.hasOnce&&(a!==H||d>0&&d&64)?ye(l,t,n,!1,!0):(a===H&&d&384||!i&&u&16)&&ye(c,t,n),r&&ge(e)}let v=m!=null&&p==null;(g&&(_=o&&o.onVnodeUnmounted)||h||v)&&V(()=>{_&&zi(_,t,e),h&&Tn(e,null,t,`unmounted`),v&&(e.el=null)},n)},ge=e=>{let{type:t,el:n,anchor:r,transition:i}=e;if(t===H){_e(n,r);return}if(t===xi){S(e);return}let a=()=>{s(n),i&&!i.persisted&&i.afterLeave&&i.afterLeave()};if(e.shapeFlag&1&&i&&!i.persisted){let{leave:t,delayLeave:r}=i,o=()=>t(n,a);r?r(e.el,a,o):o()}else a()},_e=(e,t)=>{let n;for(;e!==t;)n=h(e),s(e),e=n;s(t)},ve=(e,t,n)=>{let{bum:r,scope:i,job:a,subTree:o,um:s,m:c,a:l}=e;hi(c),hi(l),r&&se(r),i.stop(),a&&(a.flags|=8,O(o,e,t,n)),s&&V(s,t),V(()=>{e.isUnmounted=!0},t)},ye=(e,t,n,r=!1,i=!1,a=0)=>{for(let o=a;o{if(e.shapeFlag&6)return be(e.component.subTree);if(e.shapeFlag&128)return e.suspense.next();let t=h(e.anchor||e.el),n=t&&t[Pn];return n?h(n):t},xe=!1,k=(e,t,n)=>{let r;e==null?t._vnode&&(O(t._vnode,null,null,!0),r=t._vnode.component):v(t._vnode||null,e,t,null,null,null,n),t._vnode=e,xe||=(xe=!0,_n(r),vn(),!1)},Se={p:v,um:O,m:he,r:ge,mt:D,mc:w,pc:fe,pbc:T,n:be,o:e},Ce,A;return i&&([Ce,A]=i(Se)),{render:k,hydrate:Ce,createApp:kr(k,Ce)}}function li({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 ui({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function di(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function fi(e,t,n=!1){let r=e.children,i=t.children;if(d(r)&&d(i))for(let e=0;e>1,e[n[s]]0&&(t[r]=n[a-1]),n[a]=r)}}for(a=n.length,o=n[a-1];a-->0;)n[a]=o,o=t[o];return n}function mi(e){let t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:mi(t)}function hi(e){if(e)for(let t=0;te.__isSuspense;function vi(e,t){t&&t.pendingBranch?d(e)?t.effects.push(...e):t.effects.push(e):gn(e)}var H=Symbol.for(`v-fgt`),yi=Symbol.for(`v-txt`),bi=Symbol.for(`v-cmt`),xi=Symbol.for(`v-stc`),Si=[],U=null;function W(e=!1){Si.push(U=e?null:[])}function Ci(){Si.pop(),U=Si[Si.length-1]||null}var wi=1;function Ti(e,t=!1){wi+=e,e<0&&U&&t&&(U.hasOnce=!0)}function Ei(e){return e.dynamicChildren=wi>0?U||n:null,Ci(),wi>0&&U&&U.push(e),e}function G(e,t,n,r,i,a){return Ei(q(e,t,n,r,i,a,!0))}function K(e,t,n,r,i){return Ei(J(e,t,n,r,i,!0))}function Di(e){return e?e.__v_isVNode===!0:!1}function Oi(e,t){return e.type===t.type&&e.key===t.key}var ki=({key:e})=>e??null,Ai=({ref:e,ref_key:t,ref_for:n})=>(typeof e==`number`&&(e=``+e),e==null?null:g(e)||F(e)||h(e)?{i:xn,r:e,k:t,f:!!n}:e);function q(e,t=null,n=null,r=0,i=null,a=e===H?0:1,o=!1,s=!1){let c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&ki(t),ref:t&&Ai(t),scopeId:Sn,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:a,patchFlag:r,dynamicProps:i,dynamicChildren:null,appContext:null,ctx:xn};return s?(Li(c,n),a&128&&e.normalize(c)):n&&(c.shapeFlag|=g(n)?8:16),wi>0&&!o&&U&&(c.patchFlag>0||a&6)&&c.patchFlag!==32&&U.push(c),c}var J=ji;function ji(e,t=null,n=null,r=0,i=null,a=!1){if((!e||e===sr)&&(e=bi),Di(e)){let r=Ni(e,t,!0);return n&&Li(r,n),wi>0&&!a&&U&&(r.shapeFlag&6?U[U.indexOf(e)]=r:U.push(r)),r.patchFlag=-2,r}if(aa(e)&&(e=e.__vccOpts),t){t=Mi(t);let{class:e,style:n}=t;e&&!g(e)&&(t.class=O(e)),v(n)&&(zt(n)&&!d(n)&&(n=s({},n)),t.style=de(n))}let o=g(e)?1:_i(e)?128:Fn(e)?64:v(e)?4:h(e)?2:0;return q(e,t,n,r,i,o,a,!0)}function Mi(e){return e?zt(e)||Gr(e)?s({},e):e:null}function Ni(e,t,n=!1,r=!1){let{props:i,ref:a,patchFlag:o,children:s,transition:c}=e,l=t?Ri(i||{},t):i,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:l,key:l&&ki(l),ref:t&&t.ref?n&&a?d(a)?a.concat(Ai(t)):[a,Ai(t)]:Ai(t):a,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!==H?o===-1?16:o|16:o,dynamicProps:e.dynamicProps,dynamicChildren:e.dynamicChildren,appContext:e.appContext,dirs:e.dirs,transition:c,component:e.component,suspense:e.suspense,ssContent:e.ssContent&&Ni(e.ssContent),ssFallback:e.ssFallback&&Ni(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return c&&r&&Ln(u,c.clone(u)),u}function Pi(e=` `,t=0){return J(yi,null,e,t)}function Y(e=``,t=!1){return t?(W(),K(bi,null,e)):J(bi,null,e)}function Fi(e){return e==null||typeof e==`boolean`?J(bi):d(e)?J(H,null,e.slice()):Di(e)?Ii(e):J(yi,null,String(e))}function Ii(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:Ni(e)}function Li(e,t){let n=0,{shapeFlag:r}=e;if(t==null)t=null;else if(d(t))n=16;else if(typeof t==`object`)if(r&65){let n=t.default;n&&(n._c&&(n._d=!1),Li(e,n()),n._c&&(n._d=!0));return}else{n=32;let r=t._;!r&&!Gr(t)?t._ctx=xn:r===3&&xn&&(xn.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}else if(h(t)){if(r&65){Li(e,{default:t});return}t={default:t,_ctx:xn},n=32}else t=String(t),r&64?(n=16,t=[Pi(t)]):n=8;e.children=t,e.shapeFlag|=n}function Ri(...e){let t={};for(let n=0;nX||xn,Wi,Gi;{let e=ue(),t=(t,n)=>{let r;return(r=e[t])||(r=e[t]=[]),r.push(n),e=>{r.length>1?r.forEach(t=>t(e)):r[0](e)}};Wi=t(`__VUE_INSTANCE_SETTERS__`,e=>X=e),Gi=t(`__VUE_SSR_SETTERS__`,e=>Yi=e)}var Ki=e=>{let t=X;return Wi(e),e.scope.on(),()=>{e.scope.off(),Wi(t)}},qi=()=>{X&&X.scope.off(),Wi(null)};function Ji(e){return e.vnode.shapeFlag&4}var Yi=!1;function Xi(e,t=!1,n=!1){t&&Gi(t);let{props:r,children:i}=e.vnode,a=Ji(e);Kr(e,r,a,t),ai(e,i,n||t);let o=a?Zi(e,t):void 0;return t&&Gi(!1),o}function Zi(e,t){let n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,dr);let{setup:r}=n;if(r){He();let n=e.setupContext=r.length>1?ra(e):null,i=Ki(e),a=nn(r,e,0,[e.props,n]),o=y(a);if(Ue(),i(),(o||e.sp)&&!Un(e)&&Rn(e),o){if(a.then(qi,qi),t)return a.then(n=>{Qi(e,n,t)}).catch(t=>{rn(t,e,0)});e.asyncDep=a}else Qi(e,a,t)}else ta(e,t)}function Qi(e,t,n){h(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:v(t)&&(e.setupState=qt(t)),ta(e,n)}var $i,ea;function ta(e,t,n){let i=e.type;if(!e.render){if(!t&&$i&&!i.render){let t=i.template||vr(e).template;if(t){let{isCustomElement:n,compilerOptions:r}=e.appContext.config,{delimiters:a,compilerOptions:o}=i;i.render=$i(t,s(s({isCustomElement:n,delimiters:a},r),o))}}e.render=i.render||r,ea&&ea(e)}{let t=Ki(e);He();try{mr(e)}finally{Ue(),t()}}}var na={get(e,t){return M(e,`get`,``),e[t]}};function ra(e){return{attrs:new Proxy(e.attrs,na),slots:e.slots,emit:e.emit,expose:t=>{e.exposed=t||{}}}}function ia(e){return e.exposed?e.exposeProxy||=new Proxy(qt(Bt(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in lr)return lr[n](e)},has(e,t){return t in e||t in lr}}):e.proxy}function aa(e){return h(e)&&`__vccOpts`in e}var oa=(e,t)=>Yt(e,t,Yi),sa=`3.5.39`,ca=void 0,la=typeof window<`u`&&window.trustedTypes;if(la)try{ca=la.createPolicy(`vue`,{createHTML:e=>e})}catch{}var ua=ca?e=>ca.createHTML(e):e=>e,da=`http://www.w3.org/2000/svg`,fa=`http://www.w3.org/1998/Math/MathML`,pa=typeof document<`u`?document:null,ma=pa&&pa.createElement(`template`),ha={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{let t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,r)=>{let i=t===`svg`?pa.createElementNS(da,e):t===`mathml`?pa.createElementNS(fa,e):n?pa.createElement(e,{is:n}):pa.createElement(e);return e===`select`&&r&&r.multiple!=null&&i.setAttribute(`multiple`,r.multiple),i},createText:e=>pa.createTextNode(e),createComment:e=>pa.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>pa.querySelector(e),setScopeId(e,t){e.setAttribute(t,``)},insertStaticContent(e,t,n,r,i,a){let o=n?n.previousSibling:t.lastChild;if(i&&(i===a||i.nextSibling))for(;t.insertBefore(i.cloneNode(!0),n),!(i===a||!(i=i.nextSibling)););else{ma.innerHTML=ua(r===`svg`?`${e}`:r===`mathml`?`${e}`:e);let i=ma.content;if(r===`svg`||r===`mathml`){let e=i.firstChild;for(;e.firstChild;)i.appendChild(e.firstChild);i.removeChild(e)}t.insertBefore(i,n)}return[o?o.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},ga=Symbol(`_vtc`);function _a(e,t,n){let r=e[ga];r&&(t=(t?[t,...r]:[...r]).join(` `)),t==null?e.removeAttribute(`class`):n?e.setAttribute(`class`,t):e.className=t}var va=Symbol(`_vod`),ya=Symbol(`_vsh`),ba=Symbol(``),xa=/(?:^|;)\s*display\s*:/;function Sa(e,t,n){let r=e.style,i=g(n),a=!1;if(n&&!i){if(t)if(g(t))for(let e of t.split(`;`)){let t=e.slice(0,e.indexOf(`:`)).trim();n[t]??wa(r,t,``)}else for(let e in t)n[e]??wa(r,e,``);for(let i in n){i===`display`&&(a=!0);let o=n[i];o==null?wa(r,i,``):Oa(e,i,!g(t)&&t?t[i]:void 0,o)||wa(r,i,o)}}else if(i){if(t!==n){let e=r[ba];e&&(n+=`;`+e),r.cssText=n,a=xa.test(n)}}else t&&e.removeAttribute(`style`);va in e&&(e[va]=a?r.display:``,e[ya]&&(r.display=`none`))}var Ca=/\s*!important$/;function wa(e,t,n){if(d(n))n.forEach(n=>wa(e,t,n));else if(n??=``,t.startsWith(`--`))e.setProperty(t,n);else{let r=Da(e,t);Ca.test(n)?e.setProperty(T(r),n.replace(Ca,``),`important`):e[r]=n}}var Ta=[`Webkit`,`Moz`,`ms`],Ea={};function Da(e,t){let n=Ea[t];if(n)return n;let r=w(t);if(r!==`filter`&&r in e)return Ea[t]=r;r=ae(r);for(let n=0;nza||=(Ba.then(()=>za=0),Date.now());function Ha(e,t){let n=e=>{if(!e._vts)e._vts=Date.now();else if(e._vts<=n.attached)return;let r=n.value;if(d(r)){let n=e.stopImmediatePropagation;e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0};let i=r.slice(),a=[e];for(let n=0;ne.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,Wa=(e,t,n,r,i,s)=>{let c=i===`svg`;t===`class`?_a(e,r,c):t===`style`?Sa(e,n,r):a(t)?o(t)||Fa(e,t,n,r,s):(t[0]===`.`?(t=t.slice(1),!0):t[0]===`^`?(t=t.slice(1),!1):Ga(e,t,r,c))?(ja(e,t,r),!e.tagName.includes(`-`)&&(t===`value`||t===`checked`||t===`selected`)&&Aa(e,t,r,c,s,t!==`value`)):e._isVueCE&&(Ka(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!g(r)))?ja(e,w(t),r,s,t):(t===`true-value`?e._trueValue=r:t===`false-value`&&(e._falseValue=r),Aa(e,t,r,c))};function Ga(e,t,n,r){if(r)return!!(t===`innerHTML`||t===`textContent`||t in e&&Ua(t)&&h(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`){let t=e.tagName;if(t===`IMG`||t===`VIDEO`||t===`CANVAS`||t===`SOURCE`)return!1}return Ua(t)&&g(n)?!1:t in e}function Ka(e,t){let n=e._def.props;if(!n)return!1;let r=w(t);return Array.isArray(n)?n.some(e=>w(e)===r):Object.keys(n).some(e=>w(e)===r)}var qa=[`ctrl`,`shift`,`alt`,`meta`],Ja={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)=>qa.some(n=>e[`${n}Key`]&&!t.includes(n))},Ya=(e,t)=>{if(!e)return e;let n=e._withMods||={},r=t.join(`.`);return n[r]||(n[r]=((n,...r)=>{for(let e=0;e{let t=Qa().createApp(...e),{mount:n}=t;return t.mount=e=>{let r=to(e);if(!r)return;let i=t._component;!h(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent=``);let a=n(r,!1,eo(r));return r instanceof Element&&(r.removeAttribute(`v-cloak`),r.setAttribute(`data-v-app`,``)),a},t});function eo(e){if(e instanceof SVGElement)return`svg`;if(typeof MathMLElement==`function`&&e instanceof MathMLElement)return`mathml`}function to(e){return g(e)?document.querySelector(e):e}var no=`/api`;function ro(e){if(!e)return``;let t=new URLSearchParams;for(let[n,r]of Object.entries(e))r!=null&&t.set(n,r);let n=t.toString();return n?`?${n}`:``}async function io(e,{method:t=`GET`,body:n,query:r}={}){let i={method:t};n!==void 0&&(i.headers={"Content-Type":`application/json`},i.body=JSON.stringify(n));let a=await fetch(`${no}${e}${ro(r)}`,i);if(!a.ok){let e=`Fehler (HTTP ${a.status})`;try{let t=await a.json();t.detail&&(e=typeof t.detail==`string`?t.detail:JSON.stringify(t.detail))}catch{}let t=Error(e);throw t.status=a.status,t}let o=await a.text();return o?JSON.parse(o):null}var ao=()=>io(`/projekte`),oo=e=>io(`/projekte/${encodeURIComponent(e)}`),so=(e,t)=>io(`/projekte/${encodeURIComponent(e)}/einheit`,{query:{id:t}}),co=(e,t)=>io(`/projekte/${encodeURIComponent(e)}/scan`,{method:`POST`,body:{art:t}}),lo=e=>io(`/projekte/${encodeURIComponent(e)}/scan-status`);function uo(e,t,n=3e3){let r=null;function i(){r&&=(clearInterval(r),null)}function a(){i(),r=setInterval(async()=>{await e(),t()||i()},n)}function o(){return!!r}async function s(){document.hidden?i():(await e(),t()&&a())}return document.addEventListener(`visibilitychange`,s),nr(()=>{i(),document.removeEventListener(`visibilitychange`,s)}),{start:a,stop:i,running:o}}var fo=(e,t)=>{let n=e.__vccOpts||e;for(let[e,r]of t)n[e]=r;return n},po={class:`zeile`},mo={key:1,class:`name`},ho={key:2,class:`badge gelb`},go={key:3,class:`badge rot`},_o={key:4,class:`badge gelb`},vo={key:5,class:`badge gelb`},yo={key:6,class:`badge gruen`},bo={key:0,class:`detail`},xo={key:1,class:`detail`},So={key:2,class:`detail drift`},Co={key:3,class:`aktionen`},wo=[`disabled`],To=[`disabled`],Eo={key:4,class:`meldung`},Do=fo({__name:`ProjektKarte`,props:{projekt:{type:Object,required:!0}},emits:[`oeffne`,`aktualisiert`],setup(e,{emit:t}){let n=e,r=t,i=I(``);async function a(e){i.value=``;try{await co(n.projekt.name,e),r(`aktualisiert`)}catch(e){i.value=e.message}}function o(e){return e?new Date(e).toLocaleString(`de-DE`,{dateStyle:`short`,timeStyle:`short`}):`nie gescannt`}return(t,n)=>(W(),G(`div`,{class:O([`karte`,{tot:e.projekt.fehler}])},[q(`div`,po,[!e.projekt.fehler&&e.projekt.hat_planer?(W(),G(`a`,{key:0,href:`#`,class:`name`,onClick:n[0]||=Ya(e=>t.$emit(`oeffne`),[`prevent`])},k(e.projekt.name),1)):(W(),G(`span`,mo,k(e.projekt.name),1)),e.projekt.scan_laeuft?(W(),G(`span`,ho,`läuft`)):e.projekt.fehler?(W(),G(`span`,go,`Fehler`)):e.projekt.hat_planer?e.projekt.drift?.length?(W(),G(`span`,vo,`Drift: `+k(e.projekt.drift.length),1)):(W(),G(`span`,yo,`aktuell`)):(W(),G(`span`,_o,`ungescannt`))]),e.projekt.fehler?(W(),G(`p`,bo,k(e.projekt.fehler),1)):(W(),G(`p`,xo,k(e.projekt.pfad)+` · letzter Scan: `+k(o(e.projekt.letzter_scan_ts)),1)),e.projekt.drift?.length?(W(),G(`p`,So,`veraltet: `+k(e.projekt.drift.join(`, `)),1)):Y(``,!0),e.projekt.fehler?Y(``,!0):(W(),G(`div`,Co,[e.projekt.hat_planer?(W(),G(`button`,{key:1,disabled:e.projekt.scan_laeuft,onClick:n[2]||=e=>a(`rescan`)},`Re-Scan`,8,To)):(W(),G(`button`,{key:0,class:`primaer`,disabled:e.projekt.scan_laeuft,onClick:n[1]||=e=>a(`scan`)},`Scannen`,8,wo))])),i.value?(W(),G(`p`,Eo,k(i.value),1)):Y(``,!0)],2))}},[[`__scopeId`,`data-v-f7a93d8e`]]),Oo={key:0,class:`fehler`},ko={key:1,class:`leer`},Ao={class:`liste`},jo=fo({__name:`StartSeite`,emits:[`oeffne`],setup(e){let t=I([]),n=I(``);async function r(){try{t.value=await ao(),n.value=``}catch(e){n.value=e.message}}let i=uo(r,()=>t.value.some(e=>e.scan_laeuft),3e3);return Qn(async()=>{await r(),i.start()}),(e,a)=>(W(),G(H,null,[n.value?(W(),G(`p`,Oo,k(n.value),1)):t.value.length?Y(``,!0):(W(),G(`p`,ko,[...a[1]||=[Pi(` Keine Projekte — Pfade in `,-1),q(`code`,null,`projekte.txt`,-1),Pi(` eintragen (eine Zeile = ein Repo). `,-1)]])),q(`div`,Ao,[(W(!0),G(H,null,z(t.value,t=>(W(),K(Do,{key:t.name,projekt:t,onOeffne:n=>e.$emit(`oeffne`,t.name),onAktualisiert:a[0]||=e=>{r(),Gt(i).start()}},null,8,[`projekt`,`onOeffne`]))),128))])],64))}},[[`__scopeId`,`data-v-78297d84`]]);function Mo(){return{async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null}}var No=Mo();function Po(e){No=e}var Fo={exec:()=>null};function Io(e){let t=[];return n=>{let r=Math.max(0,Math.min(3,n-1)),i=t[r];return i||(i=e(r),t[r]=i),i}}function Z(e,t=``){let n=typeof e==`string`?e:e.source,r={replace:(e,t)=>{let i=typeof t==`string`?t:t.source;return i=i.replace(Q.caret,`$1`),n=n.replace(e,i),r},getRegex:()=>new RegExp(n,t)};return r}var Lo=((e=``)=>{try{return!!RegExp(`(?<=1)(?/,blockquoteSetextReplace:/\n {0,3}((?:=+|-+) *)(?=\n|$)/g,blockquoteSetextReplace2:/^ {0,3}>[ \t]?/gm,listReplaceNesting:/^ {1,4}(?=( {4})*[^ ])/g,listIsTask:/^\[[ xX]\] +\S/,listReplaceTask:/^\[[ xX]\] +/,listTaskCheckbox:/\[[ 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,caret:/(^|[^\[])\^/g,percentDecode:/%25/g,findPipe:/\|/g,splitPipe:/ \|/,slashPipe:/\\\|/g,carriageReturn:/\r\n|\r/g,spaceLine:/^ +$/gm,notSpaceStart:/^\S*/,endingNewline:/\n$/,listItemRegex:e=>RegExp(`^( {0,3}${e})((?:[ ][^\\n]*)?(?:\\n|$))`),nextBulletRegex:Io(e=>RegExp(`^ {0,${e}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`)),hrRegex:Io(e=>RegExp(`^ {0,${e}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`)),fencesBeginRegex:Io(e=>RegExp(`^ {0,${e}}(?:\`\`\`|~~~)`)),headingBeginRegex:Io(e=>RegExp(`^ {0,${e}}#`)),htmlBeginRegex:Io(e=>RegExp(`^ {0,${e}}<(?:[a-z].*>|!--)`,`i`)),blockquoteBeginRegex:Io(e=>RegExp(`^ {0,${e}}>`))},Ro=/^(?:[ \t]*(?:\n|$))+/,zo=/^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/,Bo=/^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,Vo=/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,Ho=/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,Uo=/ {0,3}(?:[*+-]|\d{1,9}[.)])/,Wo=/^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,Go=Z(Wo).replace(/bull/g,Uo).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(),Ko=Z(Wo).replace(/bull/g,Uo).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(),qo=/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,Jo=/^[^\n]+/,Yo=/(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/,Xo=Z(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace(`label`,Yo).replace(`title`,/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(),Zo=Z(/^(bull)([ \t][^\n]*?)?(?:\n|$)/).replace(/bull/g,Uo).getRegex(),Qo=`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`,$o=/|$))/,es=Z(`^ {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`,$o).replace(`tag`,Qo).replace(`attribute`,/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),ts=Z(qo).replace(`hr`,Vo).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[.)])[ \\t]+[^ \\t\\n]`).replace(`html`,`)|<(?:script|pre|style|textarea|!--)`).replace(`tag`,Qo).getRegex(),ns={blockquote:Z(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace(`paragraph`,ts).getRegex(),code:zo,def:Xo,fences:Bo,heading:Ho,hr:Vo,html:es,lheading:Go,list:Zo,newline:Ro,paragraph:ts,table:Fo,text:Jo},rs=Z(`^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)`).replace(`hr`,Vo).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[.)])[ \\t]`).replace(`html`,`)|<(?:script|pre|style|textarea|!--)`).replace(`tag`,Qo).getRegex(),is={...ns,lheading:Ko,table:rs,paragraph:Z(qo).replace(`hr`,Vo).replace(`heading`,` {0,3}#{1,6}(?:\\s|$)`).replace(`|lheading`,``).replace(`table`,rs).replace(`blockquote`,` {0,3}>`).replace(`fences`," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace(`list`,` {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]`).replace(`html`,`)|<(?:script|pre|style|textarea|!--)`).replace(`tag`,Qo).getRegex()},as={...ns,html:Z(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace(`comment`,$o).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:Fo,lheading:/^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,paragraph:Z(qo).replace(`hr`,Vo).replace(`heading`,` *#{1,6} *[^ +]`).replace(`lheading`,Go).replace(`|table`,``).replace(`blockquote`,` {0,3}>`).replace(`|fences`,``).replace(`|list`,``).replace(`|html`,``).replace(`|tag`,``).getRegex()},os=/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,ss=/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,cs=/^( {2,}|\\)\n(?!\s*$)/,ls=/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\`+)[^`]+\k(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace(`precode-`,Lo?"(?`+)[^`]+\k(?!`)/).replace(`html`,/<(?! )[^<>]*?>/).getRegex(),vs=/^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/,ys=Z(vs,`u`).replace(/punct/g,us).getRegex(),bs=Z(vs,`u`).replace(/punct/g,ms).getRegex(),xs=`^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)`,Ss=Z(xs,`gu`).replace(/notPunctSpace/g,fs).replace(/punctSpace/g,ds).replace(/punct/g,us).getRegex(),Cs=Z(xs,`gu`).replace(/notPunctSpace/g,gs).replace(/punctSpace/g,hs).replace(/punct/g,ms).getRegex(),ws=Z(`^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)`,`gu`).replace(/notPunctSpace/g,fs).replace(/punctSpace/g,ds).replace(/punct/g,us).getRegex(),Ts=Z(/^~~?(?:((?!~)punct)|[^\s~])/,`u`).replace(/punct/g,us).getRegex(),Es=Z(`^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)`,`gu`).replace(/notPunctSpace/g,fs).replace(/punctSpace/g,ds).replace(/punct/g,us).getRegex(),Ds=Z(/\\(punct)/,`gu`).replace(/punct/g,us).getRegex(),Os=Z(/^<(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(),ks=Z($o).replace(`(?:-->|$)`,`-->`).getRegex(),As=Z(`^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^`).replace(`comment`,ks).replace(`attribute`,/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(),js=/(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/,Ms=Z(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace(`label`,js).replace(`href`,/<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace(`title`,/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(),Ns=Z(/^!?\[(label)\]\[(ref)\]/).replace(`label`,js).replace(`ref`,Yo).getRegex(),Ps=Z(/^!?\[(ref)\](?:\[\])?/).replace(`ref`,Yo).getRegex(),Fs=Z(`reflink|nolink(?!\\()`,`g`).replace(`reflink`,Ns).replace(`nolink`,Ps).getRegex(),Is=/[hH][tT][tT][pP][sS]?|[fF][tT][pP]/,Ls={_backpedal:Fo,anyPunctuation:Ds,autolink:Os,blockSkip:_s,br:cs,code:ss,del:Fo,delLDelim:Fo,delRDelim:Fo,emStrongLDelim:ys,emStrongRDelimAst:Ss,emStrongRDelimUnd:ws,escape:os,link:Ms,nolink:Ps,punctuation:ps,reflink:Ns,reflinkSearch:Fs,tag:As,text:ls,url:Fo},Rs={...Ls,link:Z(/^!?\[(label)\]\((.*?)\)/).replace(`label`,js).getRegex(),reflink:Z(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace(`label`,js).getRegex()},zs={...Ls,emStrongRDelimAst:Cs,emStrongLDelim:bs,delLDelim:Ts,delRDelim:Es,url:Z(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace(`protocol`,Is).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\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/,text:Z(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\":`>`,'"':`"`,"'":`'`},Ws=e=>Us[e];function Gs(e,t){if(t){if(Q.escapeTest.test(e))return e.replace(Q.escapeReplace,Ws)}else if(Q.escapeTestNoEncode.test(e))return e.replace(Q.escapeReplaceNoEncode,Ws);return e}function Ks(e){try{e=encodeURI(e).replace(Q.percentDecode,`%`)}catch{return null}return e}function qs(e,t){let n=e.replace(Q.findPipe,(e,t,n)=>{let r=!1,i=t;for(;--i>=0&&n[i]===`\\`;)r=!r;return r?`|`:` |`}).split(Q.splitPipe),r=0;if(n[0].trim()||n.shift(),n.length>0&&!n.at(-1)?.trim()&&n.pop(),t)if(n.length>t)n.splice(t);else for(;n.length=0&&Q.blankLine.test(t[n]);)n--;return t.length-n<=2?e:t.slice(0,n+1).join(` +`)}function Xs(e,t){if(e.indexOf(t[1])===-1)return-1;let n=0;for(let r=0;r0?-2:-1}function Zs(e,t=0){let n=t,r=``;for(let t of e)if(t===` `){let e=4-n%4;r+=` `.repeat(e),n+=e}else r+=t,n++;return r}function Qs(e,t,n,r,i){let a=t.href,o=t.title||null,s=e[1].replace(i.other.outputLinkReplace,`$1`);r.state.inLink=!0;let c={type:e[0].charAt(0)===`!`?`image`:`link`,raw:n,href:a,title:o,text:s,tokens:r.inlineTokens(s)};return r.state.inLink=!1,c}function $s(e,t,n){let r=e.match(n.other.indentCodeCompensation);if(r===null)return t;let i=r[1];return t.split(` +`).map(e=>{let t=e.match(n.other.beginningSpace);if(t===null)return e;let[r]=t;return r.length>=i.length?e.slice(i.length):e}).join(` +`)}var ec=class{options;rules;lexer;constructor(e){this.options=e||No}space(e){let t=this.rules.block.newline.exec(e);if(t&&t[0].length>0)return{type:`space`,raw:t[0]}}code(e){let t=this.rules.block.code.exec(e);if(t){let e=this.options.pedantic?t[0]:Ys(t[0]);return{type:`code`,raw:e,codeBlockStyle:`indented`,text:e.replace(this.rules.other.codeRemoveIndent,``)}}}fences(e){let t=this.rules.block.fences.exec(e);if(t){let e=t[0],n=$s(e,t[3]||``,this.rules);return{type:`code`,raw:e,lang:t[2]?t[2].trim().replace(this.rules.inline.anyPunctuation,`$1`):t[2],text:n}}}heading(e){let t=this.rules.block.heading.exec(e);if(t){let e=t[2].trim();if(this.rules.other.endingHash.test(e)){let t=Js(e,`#`);(this.options.pedantic||!t||this.rules.other.endingSpaceChar.test(t))&&(e=t.trim())}return{type:`heading`,raw:Js(t[0],` +`),depth:t[1].length,text:e,tokens:this.lexer.inline(e)}}}hr(e){let t=this.rules.block.hr.exec(e);if(t)return{type:`hr`,raw:Js(t[0],` +`)}}blockquote(e){let t=this.rules.block.blockquote.exec(e);if(t){let e=Js(t[0],` +`).split(` +`),n=``,r=``,i=[];for(;e.length>0;){let t=!1,a=[],o;for(o=0;o1,i={type:`list`,raw:``,ordered:r,start:r?+n.slice(0,-1):``,loose:!1,items:[]};n=r?`\\d{1,9}\\${n.slice(-1)}`:`\\${n}`,this.options.pedantic&&(n=r?n:`[*+-]`);let a=this.rules.other.listItemRegex(n),o=!1;for(;e;){let n=!1,r=``,s=``;if(!(t=a.exec(e))||this.rules.block.hr.test(e))break;r=t[0],e=e.substring(r.length);let c=Zs(t[2].split(` +`,1)[0],t[1].length),l=e.split(` +`,1)[0],u=!c.trim(),d=0;if(this.options.pedantic?(d=2,s=c.trimStart()):u?d=t[1].length+1:(d=c.search(this.rules.other.nonSpaceChar),d=d>4?1:d,s=c.slice(d),d+=t[1].length),u&&this.rules.other.blankLine.test(l)&&(r+=l+` +`,e=e.substring(l.length+1),n=!0),!n){let t=this.rules.other.nextBulletRegex(d),n=this.rules.other.hrRegex(d),i=this.rules.other.fencesBeginRegex(d),a=this.rules.other.headingBeginRegex(d),o=this.rules.other.htmlBeginRegex(d),f=this.rules.other.blockquoteBeginRegex(d);for(;e;){let p=e.split(` +`,1)[0],m;if(l=p,this.options.pedantic?(l=l.replace(this.rules.other.listReplaceNesting,` `),m=l):m=l.replace(this.rules.other.tabCharGlobal,` `),i.test(l)||a.test(l)||o.test(l)||f.test(l)||t.test(l)||n.test(l))break;if(m.search(this.rules.other.nonSpaceChar)>=d||!l.trim())s+=` +`+m.slice(d);else{if(u||c.replace(this.rules.other.tabCharGlobal,` `).search(this.rules.other.nonSpaceChar)>=4||i.test(c)||a.test(c)||n.test(c))break;s+=` +`+l}u=!l.trim(),r+=p+` +`,e=e.substring(p.length+1),c=m.slice(d)}}i.loose||(o?i.loose=!0:this.rules.other.doubleBlankLine.test(r)&&(o=!0)),i.items.push({type:`list_item`,raw:r,task:!!this.options.gfm&&this.rules.other.listIsTask.test(s),loose:!1,text:s,tokens:[]}),i.raw+=r}let s=i.items.at(-1);if(s)s.raw=s.raw.trimEnd(),s.text=s.text.trimEnd();else return;i.raw=i.raw.trimEnd();for(let e of i.items){this.lexer.state.top=!1,e.tokens=this.lexer.blockTokens(e.text,[]);let t=e.tokens[0];if(e.task&&(t?.type===`text`||t?.type===`paragraph`)){e.text=e.text.replace(this.rules.other.listReplaceTask,``),t.raw=t.raw.replace(this.rules.other.listReplaceTask,``),t.text=t.text.replace(this.rules.other.listReplaceTask,``);for(let e=this.lexer.inlineQueue.length-1;e>=0;e--)if(this.rules.other.listIsTask.test(this.lexer.inlineQueue[e].src)){this.lexer.inlineQueue[e].src=this.lexer.inlineQueue[e].src.replace(this.rules.other.listReplaceTask,``);break}let n=this.rules.other.listTaskCheckbox.exec(e.raw);if(n){let t={type:`checkbox`,raw:n[0]+` `,checked:n[0]!==`[ ]`};e.checked=t.checked,i.loose?e.tokens[0]&&[`paragraph`,`text`].includes(e.tokens[0].type)&&`tokens`in e.tokens[0]&&e.tokens[0].tokens?(e.tokens[0].raw=t.raw+e.tokens[0].raw,e.tokens[0].text=t.raw+e.tokens[0].text,e.tokens[0].tokens.unshift(t)):e.tokens.unshift({type:`paragraph`,raw:t.raw,text:t.raw,tokens:[t]}):e.tokens.unshift(t)}}else e.task&&=!1;if(!i.loose){let t=e.tokens.filter(e=>e.type===`space`);i.loose=t.length>0&&t.some(e=>this.rules.other.anyLine.test(e.raw))}}if(i.loose)for(let e of i.items){e.loose=!0;for(let t of e.tokens)t.type===`text`&&(t.type=`paragraph`)}return i}}html(e){let t=this.rules.block.html.exec(e);if(t){let e=Ys(t[0]);return{type:`html`,block:!0,raw:e,pre:t[1]===`pre`||t[1]===`script`||t[1]===`style`,text:e}}}def(e){let t=this.rules.block.def.exec(e);if(t){let e=t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal,` `),n=t[2]?t[2].replace(this.rules.other.hrefBrackets,`$1`).replace(this.rules.inline.anyPunctuation,`$1`):``,r=t[3]?t[3].substring(1,t[3].length-1).replace(this.rules.inline.anyPunctuation,`$1`):t[3];return{type:`def`,tag:e,raw:Js(t[0],` +`),href:n,title:r}}}table(e){let t=this.rules.block.table.exec(e);if(!t||!this.rules.other.tableDelimiter.test(t[2]))return;let n=qs(t[1]),r=t[2].replace(this.rules.other.tableAlignChars,``).split(`|`),i=t[3]?.trim()?t[3].replace(this.rules.other.tableRowBlankLine,``).split(` +`):[],a={type:`table`,raw:Js(t[0],` +`),header:[],align:[],rows:[]};if(n.length===r.length){for(let e of r)this.rules.other.tableAlignRight.test(e)?a.align.push(`right`):this.rules.other.tableAlignCenter.test(e)?a.align.push(`center`):this.rules.other.tableAlignLeft.test(e)?a.align.push(`left`):a.align.push(null);for(let e=0;e({text:e,tokens:this.lexer.inline(e),header:!1,align:a.align[t]})));return a}}lheading(e){let t=this.rules.block.lheading.exec(e);if(t){let e=t[1].trim();return{type:`heading`,raw:Js(t[0],` +`),depth:t[2].charAt(0)===`=`?1:2,text:e,tokens:this.lexer.inline(e)}}}paragraph(e){let t=this.rules.block.paragraph.exec(e);if(t){let e=t[1].charAt(t[1].length-1)===` +`?t[1].slice(0,-1):t[1];return{type:`paragraph`,raw:t[0],text:e,tokens:this.lexer.inline(e)}}}text(e){let 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){let t=this.rules.inline.escape.exec(e);if(t)return{type:`escape`,raw:t[0],text:t[1]}}tag(e){let 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){let t=this.rules.inline.link.exec(e);if(t){let e=t[2].trim();if(!this.options.pedantic&&this.rules.other.startAngleBracket.test(e)){if(!this.rules.other.endAngleBracket.test(e))return;let t=Js(e.slice(0,-1),`\\`);if((e.length-t.length)%2==0)return}else{let e=Xs(t[2],`()`);if(e===-2)return;if(e>-1){let n=(t[0].indexOf(`!`)===0?5:4)+t[1].length+e;t[2]=t[2].substring(0,e),t[0]=t[0].substring(0,n).trim(),t[3]=``}}let n=t[2],r=``;if(this.options.pedantic){let e=this.rules.other.pedanticHrefTitle.exec(n);e&&(n=e[1],r=e[3])}else r=t[3]?t[3].slice(1,-1):``;return n=n.trim(),this.rules.other.startAngleBracket.test(n)&&(n=this.options.pedantic&&!this.rules.other.endAngleBracket.test(e)?n.slice(1):n.slice(1,-1)),Qs(t,{href:n&&n.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))){let e=t[(n[2]||n[1]).replace(this.rules.other.multipleSpaceGlobal,` `).toLowerCase()];if(!e){let e=n[0].charAt(0);return{type:`text`,raw:e,text:e}}return Qs(n,e,n[0],this.lexer,this.rules)}}emStrong(e,t,n=``){let r=this.rules.inline.emStrongLDelim.exec(e);if(!(!r||!r[1]&&!r[2]&&!r[3]&&!r[4]||r[4]&&n.match(this.rules.other.unicodeAlphaNumeric))&&(!(r[1]||r[3])||!n||this.rules.inline.punctuation.exec(n))){let n=[...r[0]].length-1,i,a,o=n,s=0,c=r[0][0]===`*`?this.rules.inline.emStrongRDelimAst:this.rules.inline.emStrongRDelimUnd;for(c.lastIndex=0,t=t.slice(-1*e.length+n);(r=c.exec(t))!==null;){if(i=r[1]||r[2]||r[3]||r[4]||r[5]||r[6],!i)continue;if(a=[...i].length,r[3]||r[4]){o+=a;continue}else if((r[5]||r[6])&&n%3&&!((n+a)%3)){s+=a;continue}if(o-=a,o>0)continue;a=Math.min(a,a+o+s);let t=[...r[0]][0].length,c=e.slice(0,n+r.index+t+a);if(Math.min(n,a)%2){let e=c.slice(1,-1);return{type:`em`,raw:c,text:e,tokens:this.lexer.inlineTokens(e)}}let l=c.slice(2,-2);return{type:`strong`,raw:c,text:l,tokens:this.lexer.inlineTokens(l)}}}}codespan(e){let t=this.rules.inline.code.exec(e);if(t){let e=t[2].replace(this.rules.other.newLineCharGlobal,` `),n=this.rules.other.nonSpaceChar.test(e),r=this.rules.other.startingSpaceChar.test(e)&&this.rules.other.endingSpaceChar.test(e);return n&&r&&(e=e.substring(1,e.length-1)),{type:`codespan`,raw:t[0],text:e}}}br(e){let t=this.rules.inline.br.exec(e);if(t)return{type:`br`,raw:t[0]}}del(e,t,n=``){let r=this.rules.inline.delLDelim.exec(e);if(r&&(!r[1]||!n||this.rules.inline.punctuation.exec(n))){let n=[...r[0]].length-1,i,a,o=n,s=this.rules.inline.delRDelim;for(s.lastIndex=0,t=t.slice(-1*e.length+n);(r=s.exec(t))!==null;){if(i=r[1]||r[2]||r[3]||r[4]||r[5]||r[6],!i||(a=[...i].length,a!==n))continue;if(r[3]||r[4]){o+=a;continue}if(o-=a,o>0)continue;a=Math.min(a,a+o);let t=[...r[0]][0].length,s=e.slice(0,n+r.index+t+a),c=s.slice(n,-n);return{type:`del`,raw:s,text:c,tokens:this.lexer.inlineTokens(c)}}}}autolink(e){let t=this.rules.inline.autolink.exec(e);if(t){let e,n;return t[2]===`@`?(e=t[1],n=`mailto:`+e):(e=t[1],n=e),{type:`link`,raw:t[0],text:e,href:n,tokens:[{type:`text`,raw:e,text:e}]}}}url(e){let t;if(t=this.rules.inline.url.exec(e)){let e,n;if(t[2]===`@`)e=t[0],n=`mailto:`+e;else{let r;do r=t[0],t[0]=this.rules.inline._backpedal.exec(t[0])?.[0]??``;while(r!==t[0]);e=t[0],n=t[1]===`www.`?`http://`+t[0]:t[0]}return{type:`link`,raw:t[0],text:e,href:n,tokens:[{type:`text`,raw:e,text:e}]}}}inlineText(e){let t=this.rules.inline.text.exec(e);if(t){let e=this.lexer.state.inRawBlock;return{type:`text`,raw:t[0],text:t[0],escaped:e}}}},tc=class e{tokens;options;state;inlineQueue;tokenizer;constructor(e){this.tokens=[],this.tokens.links=Object.create(null),this.options=e||No,this.options.tokenizer=this.options.tokenizer||new ec,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options,this.tokenizer.lexer=this,this.inlineQueue=[],this.state={inLink:!1,inRawBlock:!1,top:!0};let t={other:Q,block:Vs.normal,inline:Hs.normal};this.options.pedantic?(t.block=Vs.pedantic,t.inline=Hs.pedantic):this.options.gfm&&(t.block=Vs.gfm,this.options.breaks?t.inline=Hs.breaks:t.inline=Hs.gfm),this.tokenizer.rules=t}static get rules(){return{block:Vs,inline:Hs}}static lex(t,n){return new e(n).lex(t)}static lexInline(t,n){return new e(n).inlineTokens(t)}lex(e){e=e.replace(Q.carriageReturn,` +`),this.blockTokens(e,this.tokens);for(let e=0;e(i=n.call({lexer:this},e,t))?(e=e.substring(i.raw.length),t.push(i),!0):!1))continue;if(i=this.tokenizer.space(e)){e=e.substring(i.raw.length);let n=t.at(-1);i.raw.length===1&&n!==void 0?n.raw+=` +`:t.push(i);continue}if(i=this.tokenizer.code(e)){e=e.substring(i.raw.length);let n=t.at(-1);n?.type===`paragraph`||n?.type===`text`?(n.raw+=(n.raw.endsWith(` +`)?``:` +`)+i.raw,n.text+=` +`+i.text,this.inlineQueue.at(-1).src=n.text):t.push(i);continue}if(i=this.tokenizer.fences(e)){e=e.substring(i.raw.length),t.push(i);continue}if(i=this.tokenizer.heading(e)){e=e.substring(i.raw.length),t.push(i);continue}if(i=this.tokenizer.hr(e)){e=e.substring(i.raw.length),t.push(i);continue}if(i=this.tokenizer.blockquote(e)){e=e.substring(i.raw.length),t.push(i);continue}if(i=this.tokenizer.list(e)){e=e.substring(i.raw.length),t.push(i);continue}if(i=this.tokenizer.html(e)){e=e.substring(i.raw.length),t.push(i);continue}if(i=this.tokenizer.def(e)){e=e.substring(i.raw.length);let n=t.at(-1);n?.type===`paragraph`||n?.type===`text`?(n.raw+=(n.raw.endsWith(` +`)?``:` +`)+i.raw,n.text+=` +`+i.raw,this.inlineQueue.at(-1).src=n.text):this.tokens.links[i.tag]||(this.tokens.links[i.tag]={href:i.href,title:i.title},t.push(i));continue}if(i=this.tokenizer.table(e)){e=e.substring(i.raw.length),t.push(i);continue}if(i=this.tokenizer.lheading(e)){e=e.substring(i.raw.length),t.push(i);continue}let a=e;if(this.options.extensions?.startBlock){let t=1/0,n=e.slice(1),r;this.options.extensions.startBlock.forEach(e=>{r=e.call({lexer:this},n),typeof r==`number`&&r>=0&&(t=Math.min(t,r))}),t<1/0&&t>=0&&(a=e.substring(0,t+1))}if(this.state.top&&(i=this.tokenizer.paragraph(a))){let r=t.at(-1);n&&r?.type===`paragraph`?(r.raw+=(r.raw.endsWith(` +`)?``:` +`)+i.raw,r.text+=` +`+i.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=r.text):t.push(i),n=a.length!==e.length,e=e.substring(i.raw.length);continue}if(i=this.tokenizer.text(e)){e=e.substring(i.raw.length);let n=t.at(-1);n?.type===`text`?(n.raw+=(n.raw.endsWith(` +`)?``:` +`)+i.raw,n.text+=` +`+i.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=n.text):t.push(i);continue}if(e){this.infiniteLoopError(e.charCodeAt(0));break}}return this.state.top=!0,t}inline(e,t=[]){return this.inlineQueue.push({src:e,tokens:t}),t}inlineTokens(e,t=[]){this.tokenizer.lexer=this;let n=e,r=null;if(this.tokens.links){let e=Object.keys(this.tokens.links);if(e.length>0)for(;(r=this.tokenizer.rules.inline.reflinkSearch.exec(n))!==null;)e.includes(r[0].slice(r[0].lastIndexOf(`[`)+1,-1))&&(n=n.slice(0,r.index)+`[`+`a`.repeat(r[0].length-2)+`]`+n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;(r=this.tokenizer.rules.inline.anyPunctuation.exec(n))!==null;)n=n.slice(0,r.index)+`++`+n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);let i;for(;(r=this.tokenizer.rules.inline.blockSkip.exec(n))!==null;)i=r[2]?r[2].length:0,n=n.slice(0,r.index+i)+`[`+`a`.repeat(r[0].length-i-2)+`]`+n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);n=this.options.hooks?.emStrongMask?.call({lexer:this},n)??n;let a=!1,o=``,s=1/0;for(;e;){if(e.length(r=n.call({lexer:this},e,t))?(e=e.substring(r.raw.length),t.push(r),!0):!1))continue;if(r=this.tokenizer.escape(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.tag(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.link(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.reflink(e,this.tokens.links)){e=e.substring(r.raw.length);let n=t.at(-1);r.type===`text`&&n?.type===`text`?(n.raw+=r.raw,n.text+=r.text):t.push(r);continue}if(r=this.tokenizer.emStrong(e,n,o)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.codespan(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.br(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.del(e,n,o)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.autolink(e)){e=e.substring(r.raw.length),t.push(r);continue}if(!this.state.inLink&&(r=this.tokenizer.url(e))){e=e.substring(r.raw.length),t.push(r);continue}let i=e;if(this.options.extensions?.startInline){let t=1/0,n=e.slice(1),r;this.options.extensions.startInline.forEach(e=>{r=e.call({lexer:this},n),typeof r==`number`&&r>=0&&(t=Math.min(t,r))}),t<1/0&&t>=0&&(i=e.substring(0,t+1))}if(r=this.tokenizer.inlineText(i)){e=e.substring(r.raw.length),r.raw.slice(-1)!==`_`&&(o=r.raw.slice(-1)),a=!0;let n=t.at(-1);n?.type===`text`?(n.raw+=r.raw,n.text+=r.text):t.push(r);continue}if(e){this.infiniteLoopError(e.charCodeAt(0));break}}return t}infiniteLoopError(e){let t=`Infinite loop on byte: `+e;if(this.options.silent)console.error(t);else throw Error(t)}},nc=class{options;parser;constructor(e){this.options=e||No}space(e){return``}code({text:e,lang:t,escaped:n}){let r=(t||``).match(Q.notSpaceStart)?.[0],i=e.replace(Q.endingNewline,``)+` +`;return r?`
`+(n?i:Gs(i,!0))+`
+`:`
`+(n?i:Gs(i,!0))+`
+`}blockquote({tokens:e}){return`
+${this.parser.parse(e)}
+`}html({text:e}){return e}def(e){return``}heading({tokens:e,depth:t}){return`${this.parser.parseInline(e)} +`}hr(e){return`
+`}list(e){let t=e.ordered,n=e.start,r=``;for(let t=0;t +`+r+` +`}listitem(e){return`
  • ${this.parser.parse(e.tokens)}
    • +`}checkbox({checked:e}){return` `}paragraph({tokens:e}){return`

    ${this.parser.parseInline(e)}

    +`}table(e){let t=``,n=``;for(let t=0;t${r}`,` + +`+t+` +`+r+`
    +`}tablerow({text:e}){return` +${e} +`}tablecell(e){let 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`${Gs(e,!0)}`}br(e){return`
    `}del({tokens:e}){return`${this.parser.parseInline(e)}`}link({href:e,title:t,tokens:n}){let r=this.parser.parseInline(n),i=Ks(e);if(i===null)return r;e=i;let a=`    `+r+``,a}image({href:e,title:t,text:n,tokens:r}){r&&(n=this.parser.parseInline(r,this.parser.textRenderer));let i=Ks(e);if(i===null)return Gs(n);e=i;let a=`${Gs(n)}`,a}text(e){return`tokens`in e&&e.tokens?this.parser.parseInline(e.tokens):`escaped`in e&&e.escaped?e.text:Gs(e.text)}},rc=class{strong({text:e}){return e}em({text:e}){return e}codespan({text:e}){return e}del({text:e}){return e}html({text:e}){return e}text({text:e}){return e}link({text:e}){return``+e}image({text:e}){return``+e}br(){return``}checkbox({raw:e}){return e}},ic=class e{options;renderer;textRenderer;constructor(e){this.options=e||No,this.options.renderer=this.options.renderer||new nc,this.renderer=this.options.renderer,this.renderer.options=this.options,this.renderer.parser=this,this.textRenderer=new rc}static parse(t,n){return new e(n).parse(t)}static parseInline(t,n){return new e(n).parseInline(t)}parse(e){this.renderer.parser=this;let t=``;for(let n=0;n{let i=e[r].flat(1/0);n=n.concat(this.walkTokens(i,t))}):e.tokens&&(n=n.concat(this.walkTokens(e.tokens,t)))}}return n}use(...e){let t=this.defaults.extensions||{renderers:{},childTokens:{}};return e.forEach(e=>{let n={...e};if(n.async=this.defaults.async||n.async||!1,e.extensions&&(e.extensions.forEach(e=>{if(!e.name)throw Error(`extension name required`);if(`renderer`in e){let n=t.renderers[e.name];n?t.renderers[e.name]=function(...t){let r=e.renderer.apply(this,t);return r===!1&&(r=n.apply(this,t)),r}:t.renderers[e.name]=e.renderer}if(`tokenizer`in e){if(!e.level||e.level!==`block`&&e.level!==`inline`)throw Error(`extension level must be 'block' or 'inline'`);let n=t[e.level];n?n.unshift(e.tokenizer):t[e.level]=[e.tokenizer],e.start&&(e.level===`block`?t.startBlock?t.startBlock.push(e.start):t.startBlock=[e.start]:e.level===`inline`&&(t.startInline?t.startInline.push(e.start):t.startInline=[e.start]))}`childTokens`in e&&e.childTokens&&(t.childTokens[e.name]=e.childTokens)}),n.extensions=t),e.renderer){let t=this.defaults.renderer||new nc(this.defaults);for(let n in e.renderer){if(!(n in t))throw Error(`renderer '${n}' does not exist`);if([`options`,`parser`].includes(n))continue;let r=n,i=e.renderer[r],a=t[r];t[r]=(...e)=>{let n=i.apply(t,e);return n===!1&&(n=a.apply(t,e)),n||``}}n.renderer=t}if(e.tokenizer){let t=this.defaults.tokenizer||new ec(this.defaults);for(let n in e.tokenizer){if(!(n in t))throw Error(`tokenizer '${n}' does not exist`);if([`options`,`rules`,`lexer`].includes(n))continue;let r=n,i=e.tokenizer[r],a=t[r];t[r]=(...e)=>{let n=i.apply(t,e);return n===!1&&(n=a.apply(t,e)),n}}n.tokenizer=t}if(e.hooks){let t=this.defaults.hooks||new ac;for(let n in e.hooks){if(!(n in t))throw Error(`hook '${n}' does not exist`);if([`options`,`block`].includes(n))continue;let r=n,i=e.hooks[r],a=t[r];ac.passThroughHooks.has(n)?t[r]=e=>{if(this.defaults.async&&ac.passThroughHooksRespectAsync.has(n))return(async()=>{let n=await i.call(t,e);return a.call(t,n)})();let r=i.call(t,e);return a.call(t,r)}:t[r]=(...e)=>{if(this.defaults.async)return(async()=>{let n=await i.apply(t,e);return n===!1&&(n=await a.apply(t,e)),n})();let n=i.apply(t,e);return n===!1&&(n=a.apply(t,e)),n}}n.hooks=t}if(e.walkTokens){let t=this.defaults.walkTokens,r=e.walkTokens;n.walkTokens=function(e){let n=[];return n.push(r.call(this,e)),t&&(n=n.concat(t.call(this,e))),n}}this.defaults={...this.defaults,...n}}),this}setOptions(e){return this.defaults={...this.defaults,...e},this}lexer(e,t){return tc.lex(e,t??this.defaults)}parser(e,t){return ic.parse(e,t??this.defaults)}parseMarkdown(e){return(t,n)=>{let r={...n},i={...this.defaults,...r},a=this.onError(!!i.silent,!!i.async);if(this.defaults.async===!0&&r.async===!1)return a(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 t>`u`||t===null)return a(Error(`marked(): input parameter is undefined or null`));if(typeof t!=`string`)return a(Error(`marked(): input parameter is of type `+Object.prototype.toString.call(t)+`, string expected`));if(i.hooks&&(i.hooks.options=i,i.hooks.block=e),i.async)return(async()=>{let n=i.hooks?await i.hooks.preprocess(t):t,r=await(i.hooks?await i.hooks.provideLexer(e):e?tc.lex:tc.lexInline)(n,i),a=i.hooks?await i.hooks.processAllTokens(r):r;i.walkTokens&&await Promise.all(this.walkTokens(a,i.walkTokens));let o=await(i.hooks?await i.hooks.provideParser(e):e?ic.parse:ic.parseInline)(a,i);return i.hooks?await i.hooks.postprocess(o):o})().catch(a);try{i.hooks&&(t=i.hooks.preprocess(t));let n=(i.hooks?i.hooks.provideLexer(e):e?tc.lex:tc.lexInline)(t,i);i.hooks&&(n=i.hooks.processAllTokens(n)),i.walkTokens&&this.walkTokens(n,i.walkTokens);let r=(i.hooks?i.hooks.provideParser(e):e?ic.parse:ic.parseInline)(n,i);return i.hooks&&(r=i.hooks.postprocess(r)),r}catch(e){return a(e)}}}onError(e,t){return n=>{if(n.message+=` +Please report this to https://github.com/markedjs/marked.`,e){let e=`

    An error occurred:

    `+Gs(n.message+``,!0)+`
    `;return t?Promise.resolve(e):e}if(t)return Promise.reject(n);throw n}}};function $(e,t){return oc.parse(e,t)}$.options=$.setOptions=function(e){return oc.setOptions(e),$.defaults=oc.defaults,Po($.defaults),$},$.getDefaults=Mo,$.defaults=No,$.use=function(...e){return oc.use(...e),$.defaults=oc.defaults,Po($.defaults),$},$.walkTokens=function(e,t){return oc.walkTokens(e,t)},$.parseInline=oc.parseInline,$.Parser=ic,$.parser=ic.parse,$.Renderer=nc,$.TextRenderer=rc,$.Lexer=tc,$.lexer=tc.lex,$.Tokenizer=ec,$.Hooks=ac,$.parse=$,$.options,$.setOptions,$.use,$.walkTokens,$.parseInline,ic.parse,tc.lex;var sc={class:`besch`},cc={class:`raster`},lc=[`onClick`],uc={class:`kopf`},dc={class:`besch`},fc={key:0,class:`faehigkeiten`},pc={key:1,class:`mehr`},mc=fo({__name:`FeatureBaum`,props:{projekt:{type:Object,required:!0}},setup(e){let t=I(new Set);function n(e){t.value.has(e)?t.value.delete(e):t.value.add(e),t.value=new Set(t.value)}return(r,i)=>(W(!0),G(H,null,z(e.projekt.bereiche,e=>(W(),G(`section`,{key:e.name,class:`bereich`},[q(`h3`,null,k(e.name),1),q(`p`,sc,k(e.beschreibung),1),q(`div`,cc,[(W(!0),G(H,null,z(e.features,r=>(W(),G(`div`,{key:r.titel,class:O([`karte feature`,{offen:t.value.has(e.name+r.titel)}]),onClick:t=>n(e.name+r.titel)},[q(`div`,uc,[q(`strong`,null,k(r.titel),1),q(`span`,{class:O([`badge`,r.flag===`kern`?`gruen`:`gelb`])},k(r.flag),3)]),q(`p`,dc,k(r.beschreibung),1),t.value.has(e.name+r.titel)?(W(),G(`ul`,fc,[(W(!0),G(H,null,z(r.teilfeatures,e=>(W(),G(`li`,{key:e.titel},k(e.titel),1))),128))])):(W(),G(`span`,pc,k(r.teilfeatures.length)+` Fähigkeiten ▸`,1))],10,lc))),128))])]))),128))}},[[`__scopeId`,`data-v-f039a64a`]]),hc={key:0,class:`badge gelb`},gc={class:`inhalt`},_c={key:0,class:`fehler`},vc={class:`besch`},yc={class:`io`},bc={key:0,class:`entscheidungen`},xc={key:1,class:`kanten`},Sc={key:0},Cc={key:2},wc={key:3,class:`kein-code`},Tc={key:2,class:`laden`},Ec=fo({__name:`EinheitDetail`,props:{projektName:{type:String,required:!0},id:{type:String,required:!0},kurz:{type:String,default:``}},setup(e){let t=e,n=I(null),r=I(``);async function i(){if(!(n.value||r.value))try{n.value=await so(t.projektName,t.id)}catch(e){r.value=e.message}}return(t,a)=>(W(),G(`details`,{class:`einheit`,onToggle:a[0]||=e=>e.target.open&&i()},[q(`summary`,null,[q(`code`,null,k(e.id),1),n.value?.veraltet?(W(),G(`span`,hc,`veraltet`)):Y(``,!0)]),q(`div`,gc,[r.value?(W(),G(`p`,_c,k(r.value),1)):n.value?(W(),G(H,{key:1},[q(`p`,vc,[q(`em`,null,k(n.value.beschreibung),1)]),q(`dl`,yc,[a[1]||=q(`dt`,null,`Input`,-1),q(`dd`,null,k(n.value.input||`—`),1),a[2]||=q(`dt`,null,`Output`,-1),q(`dd`,null,k(n.value.output||`—`),1)]),n.value.entscheidungen.length?(W(),G(`ul`,bc,[(W(!0),G(H,null,z(n.value.entscheidungen,(e,t)=>(W(),G(`li`,{key:t},k(e),1))),128))])):Y(``,!0),n.value.kanten.length?(W(),G(`p`,xc,[(W(!0),G(H,null,z(n.value.kanten,(e,t)=>(W(),G(H,{key:t},[t?(W(),G(`span`,Sc,` · `)):Y(``,!0),Pi(k(e.typ)+` → `,1),q(`code`,null,k(e.ziel),1)],64))),128))])):Y(``,!0),n.value.code?(W(),G(`pre`,Cc,k(n.value.code),1)):(W(),G(`p`,wc,`Anker nicht im aktuellen Code gefunden.`))],64)):(W(),G(`p`,Tc,`lädt…`))])],32))}},[[`__scopeId`,`data-v-58d66282`]]),Dc={class:`besch`},Oc={key:0,class:`beziehungen`},kc={key:0},Ac={key:0,class:`leer`},jc=fo({__name:`ArchitekturTab`,props:{projekt:{type:Object,required:!0}},setup(e){return(t,n)=>(W(),G(H,null,[(W(!0),G(H,null,z(e.projekt.architektur,t=>(W(),G(`section`,{key:t.name,class:`komponente`},[q(`h3`,null,k(t.name),1),q(`p`,Dc,k(t.beschreibung),1),t.beziehungen.length?(W(),G(`p`,Oc,[(W(!0),G(H,null,z(t.beziehungen,(e,t)=>(W(),G(H,{key:t},[t?(W(),G(`span`,kc,` · `)):Y(``,!0),Pi(k(e.typ)+` → `+k(e.ziel),1)],64))),128))])):Y(``,!0),q(`details`,null,[q(`summary`,null,k(t.einheiten.length)+` Einheiten`,1),(W(!0),G(H,null,z(t.einheiten,t=>(W(),K(Ec,{key:t,"projekt-name":e.projekt.name,id:t},null,8,[`projekt-name`,`id`]))),128))])]))),128)),e.projekt.architektur.length?Y(``,!0):(W(),G(`p`,Ac,`Keine Architektur-Sicht vorhanden.`))],64))}},[[`__scopeId`,`data-v-dc3c6459`]]),Mc={key:0,class:`refs`},Nc={key:0,class:`leer`},Pc=fo({__name:`FlowsTab`,props:{projekt:{type:Object,required:!0}},setup(e){return(t,n)=>(W(),G(H,null,[(W(!0),G(H,null,z(e.projekt.flows,t=>(W(),G(`section`,{key:t.titel,class:`flow`},[q(`h3`,null,k(t.titel),1),q(`ol`,null,[(W(!0),G(H,null,z(t.schritte,(t,n)=>(W(),G(`li`,{key:n},[Pi(k(t.text)+` `,1),t.einheiten.length?(W(),G(`details`,Mc,[q(`summary`,null,[(W(!0),G(H,null,z(t.einheiten,(e,t)=>(W(),G(`code`,{key:e},k(t?`, `:``)+k(e),1))),128))]),(W(!0),G(H,null,z(t.einheiten,t=>(W(),K(Ec,{key:t,"projekt-name":e.projekt.name,id:t},null,8,[`projekt-name`,`id`]))),128))])):Y(``,!0)]))),128))])]))),128)),e.projekt.flows.length?Y(``,!0):(W(),G(`p`,Nc,`Keine Flow-Sicht vorhanden.`))],64))}},[[`__scopeId`,`data-v-9b2e52a0`]]),Fc={class:`pruefung`},Ic={key:0},Lc=fo({__name:`PruefungTab`,props:{projekt:{type:Object,required:!0}},setup(e){return(t,n)=>(W(),G(`section`,Fc,[q(`dl`,null,[n[0]||=q(`dt`,null,`Tests`,-1),q(`dd`,null,[q(`code`,null,k(e.projekt.pruefung.tests||`—`),1)]),n[1]||=q(`dt`,null,`Lint`,-1),q(`dd`,null,[q(`code`,null,k(e.projekt.pruefung.lint||`—`),1)]),n[2]||=q(`dt`,null,`Start`,-1),q(`dd`,null,[q(`code`,null,k(e.projekt.pruefung.start||`—`),1)])]),e.projekt.pruefung.hinweise.length?(W(),G(`ul`,Ic,[(W(!0),G(H,null,z(e.projekt.pruefung.hinweise,(e,t)=>(W(),G(`li`,{key:t},k(e),1))),128))])):Y(``,!0)]))}},[[`__scopeId`,`data-v-480e8270`]]),Rc={class:`doku`},zc=[`innerHTML`],Bc=fo({__name:`DokuTab`,props:{projekt:{type:Object,required:!0}},setup(e){let t=e,n=oa(()=>{let e=Object.fromEntries(t.projekt.bereiche.map(e=>[e.name,e]));return t.projekt.doku_ordnung.map(t=>e[t]).filter(Boolean)}),r=oa(()=>$.parse(t.projekt.kern.text||``));return(t,i)=>(W(),G(`article`,Rc,[i[0]||=q(`h2`,null,`1. Kern`,-1),q(`div`,{innerHTML:r.value},null,8,zc),i[1]||=q(`h2`,null,`2. Architektur`,-1),J(jc,{projekt:e.projekt},null,8,[`projekt`]),i[2]||=q(`h2`,null,`3. Funktionsbereiche (in Einlese-Reihenfolge)`,-1),J(mc,{projekt:{...e.projekt,bereiche:n.value}},null,8,[`projekt`]),i[3]||=q(`h2`,null,`4. Abläufe`,-1),J(Pc,{projekt:e.projekt},null,8,[`projekt`])]))}},[[`__scopeId`,`data-v-b57ab26e`]]),Vc={class:`leiste`},Hc={class:`stufen`},Uc={key:0,class:`agenten`},Wc={key:1,class:`dead`},Gc=fo({__name:`ScanSeitenleiste`,props:{name:{type:String,required:!0}},setup(e){let t=e,n=I(null);async function r(){try{n.value=await lo(t.name)}catch{}}let i=uo(r,()=>n.value?.laeuft!==!1,2e3);Qn(async()=>{await r(),i.start()});function a(e){return`${Math.round(e)}s`}return(e,t)=>(W(),G(`aside`,Vc,[t[1]||=q(`h3`,null,`Scan läuft`,-1),n.value?(W(),G(H,{key:0},[q(`dl`,Hc,[(W(!0),G(H,null,z(n.value.stufen,(e,t)=>(W(),G(H,{key:t},[q(`dt`,null,k(t),1),q(`dd`,null,k(e),1)],64))),128))]),n.value.agenten.length?(W(),G(`div`,Uc,[t[0]||=q(`h4`,null,`Aktive Agenten`,-1),(W(!0),G(H,null,z(n.value.agenten,e=>(W(),G(`p`,{key:e.key,class:`agent`},[q(`code`,null,k(e.label||e.key),1),Pi(` · `+k(a(e.runtime)),1)]))),128))])):Y(``,!0),n.value.dead.length?(W(),G(`p`,Wc,`DEAD: `+k(n.value.dead.join(`, `)),1)):Y(``,!0)],64)):Y(``,!0)]))}},[[`__scopeId`,`data-v-5d2db867`]]),Kc={key:0,class:`fehler`},qc={class:`kern karte`},Jc=[`innerHTML`],Yc={key:0,class:`drift-hinweis`},Xc={key:2,class:`laden`},Zc=fo({__name:`ProjektAnsicht`,props:{name:{type:String,required:!0},ansicht:{type:String,default:`features`}},setup(e){let t=e,n=I(null),r=I(``),i=I(!1);async function a(){try{n.value=await oo(t.name),r.value=``}catch(e){r.value=e.message}}async function o(){try{let e=await lo(t.name),n=i.value;i.value=e.laeuft,n&&!e.laeuft&&await a()}catch{}}let s=uo(o,()=>i.value,2e3);Qn(async()=>{await a(),await o(),i.value&&s.start()}),An(()=>t.name,async()=>{n.value=null,await a()});let c=oa(()=>n.value?$.parse(n.value.kern.text||``):``);return(t,a)=>r.value?(W(),G(`p`,Kc,k(r.value),1)):n.value?(W(),G(`div`,{key:1,class:O([`rahmen`,{mitLeiste:i.value}])},[q(`div`,null,[q(`section`,qc,[q(`h2`,null,k(n.value.kern.titel||e.name),1),q(`div`,{class:`kern-text`,innerHTML:c.value},null,8,Jc),n.value.drift.veraltet.length?(W(),G(`p`,Yc,` ⚠ `+k(n.value.drift.veraltet.length)+` Datei(en) seit dem letzten Scan geändert — Re-Scan empfohlen. `,1)):Y(``,!0)]),e.ansicht===`features`?(W(),K(mc,{key:0,projekt:n.value},null,8,[`projekt`])):e.ansicht===`architektur`?(W(),K(jc,{key:1,projekt:n.value},null,8,[`projekt`])):e.ansicht===`flows`?(W(),K(Pc,{key:2,projekt:n.value},null,8,[`projekt`])):e.ansicht===`doku`?(W(),K(Bc,{key:3,projekt:n.value},null,8,[`projekt`])):(W(),K(Lc,{key:4,projekt:n.value},null,8,[`projekt`]))]),i.value?(W(),K(Gc,{key:0,name:e.name},null,8,[`name`])):Y(``,!0)],2)):(W(),G(`p`,Xc,`lädt…`))}},[[`__scopeId`,`data-v-50cf4d28`]]),Qc={class:`shell`},$c={class:`sidebar`},el={class:`projekte`},tl=[`onClick`],nl={key:0,class:`punkt gelb`,title:`Scan läuft`},rl={key:1,class:`punkt gelb`,title:`Drift`},il={key:2,class:`punkt gruen`,title:`aktuell`},al={key:0,class:`ansichten`},ol={class:`gruppe`},sl=[`onClick`],cl={class:`icon`};$a(fo({__name:`App`,setup(e){let t=I([]),n=I(null),r=I(`features`),i=[[`features`,`Features`,`▦`],[`architektur`,`Architektur`,`⬡`],[`flows`,`Abläufe`,`⇉`],[`doku`,`Doku`,`☰`],[`pruefung`,`Prüfung`,`✓`]];async function a(){try{t.value=await ao()}catch{}}uo(a,()=>t.value.some(e=>e.scan_laeuft),5e3),Qn(a);function o(e){n.value=e,r.value=`features`}let s=I(document.documentElement.classList.contains(`dark`));function c(){s.value=!s.value,document.documentElement.classList.toggle(`dark`,s.value),localStorage.setItem(`darkMode`,String(s.value))}return(e,a)=>(W(),G(`div`,Qc,[q(`aside`,$c,[q(`h1`,{onClick:a[0]||=e=>n.value=null},`Planer`),q(`nav`,el,[a[2]||=q(`span`,{class:`gruppe`},`Projekte`,-1),q(`a`,{href:`#`,class:O({aktiv:!n.value}),onClick:a[1]||=Ya(e=>n.value=null,[`prevent`])},` ⌂ Übersicht `,2),(W(!0),G(H,null,z(t.value,e=>(W(),G(`a`,{key:e.name,href:`#`,class:O({aktiv:n.value===e.name,gestoert:e.fehler||!e.hat_planer}),onClick:Ya(t=>e.hat_planer&&o(e.name),[`prevent`])},[Pi(k(e.name)+` `,1),e.scan_laeuft?(W(),G(`span`,nl)):e.drift?.length?(W(),G(`span`,rl)):e.hat_planer?(W(),G(`span`,il)):Y(``,!0)],10,tl))),128))]),n.value?(W(),G(`nav`,al,[q(`span`,ol,k(n.value),1),(W(),G(H,null,z(i,([e,t,n])=>q(`a`,{key:e,href:`#`,class:O({aktiv:r.value===e}),onClick:Ya(t=>r.value=e,[`prevent`])},[q(`span`,cl,k(n),1),Pi(k(t),1)],10,sl)),64))])):Y(``,!0),q(`button`,{class:`dark-knopf`,onClick:c},k(s.value?`☀ Hell`:`☾ Dunkel`),1)]),q(`main`,null,[n.value?(W(),K(Zc,{key:1,name:n.value,ansicht:r.value},null,8,[`name`,`ansicht`])):(W(),K(jo,{key:0,onOeffne:o}))])]))}},[[`__scopeId`,`data-v-bb207b1a`]])).mount(`#app`); \ No newline at end of file diff --git a/frontend/dist/index.html b/frontend/dist/index.html new file mode 100644 index 0000000..47a242f --- /dev/null +++ b/frontend/dist/index.html @@ -0,0 +1,22 @@ + + + + + + Planer + + + + + +
    + + diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..6ccc3d2 --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,21 @@ + + + + + + Planer + + + +
    + + + diff --git a/frontend/node_modules/.bin/marked b/frontend/node_modules/.bin/marked new file mode 120000 index 0000000..6827ff3 --- /dev/null +++ b/frontend/node_modules/.bin/marked @@ -0,0 +1 @@ +../marked/bin/marked.js \ No newline at end of file diff --git a/frontend/node_modules/.bin/nanoid b/frontend/node_modules/.bin/nanoid new file mode 120000 index 0000000..e2be547 --- /dev/null +++ b/frontend/node_modules/.bin/nanoid @@ -0,0 +1 @@ +../nanoid/bin/nanoid.cjs \ No newline at end of file diff --git a/frontend/node_modules/.bin/parser b/frontend/node_modules/.bin/parser new file mode 120000 index 0000000..ce7bf97 --- /dev/null +++ b/frontend/node_modules/.bin/parser @@ -0,0 +1 @@ +../@babel/parser/bin/babel-parser.js \ No newline at end of file diff --git a/frontend/node_modules/.bin/rolldown b/frontend/node_modules/.bin/rolldown new file mode 120000 index 0000000..7725012 --- /dev/null +++ b/frontend/node_modules/.bin/rolldown @@ -0,0 +1 @@ +../rolldown/bin/cli.mjs \ No newline at end of file diff --git a/frontend/node_modules/.bin/vite b/frontend/node_modules/.bin/vite new file mode 120000 index 0000000..6d1e3be --- /dev/null +++ b/frontend/node_modules/.bin/vite @@ -0,0 +1 @@ +../vite/bin/vite.js \ No newline at end of file diff --git a/frontend/node_modules/.package-lock.json b/frontend/node_modules/.package-lock.json new file mode 100644 index 0000000..b383e83 --- /dev/null +++ b/frontend/node_modules/.package-lock.json @@ -0,0 +1,559 @@ +{ + "name": "planer-frontend", + "version": "0.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "node_modules/@babel/helper-string-parser": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz", + "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz", + "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz", + "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.7" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz", + "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==", + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "license": "MIT" + }, + "node_modules/@oxc-project/types": { + "version": "0.139.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.139.0.tgz", + "integrity": "sha512-r9gHphtCs+1M7J0pw6Sn/hh/Wpa/iQrOOkrNAlVLF/gHq+/CJmHIWKKUUhdWjcD6CIa8idarspCsASiXCXvFUw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Boshen" + } + }, + "node_modules/@rolldown/binding-linux-x64-gnu": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.1.5.tgz", + "integrity": "sha512-FjcpEKUyJygHgs1o50VYNvkt5+7Le/VEdYt0AkRpkL33MnyQfwr8l5mXwMmfmTbyMPr5vJLC+8/Gd9gXnwU1QQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz", + "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@vitejs/plugin-vue": { + "version": "6.0.7", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-6.0.7.tgz", + "integrity": "sha512-km+p+XdSz9Sxm5rqUbqcSfZYaAniKxWBj1KURl+Jr7UaPvvX7BmaWMdP69I5rrFDeQGyxAG7NXdc57vz+snhWg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rolldown/pluginutils": "^1.0.1" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "peerDependencies": { + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0", + "vue": "^3.2.25" + } + }, + "node_modules/@vue/compiler-core": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.39.tgz", + "integrity": "sha512-16KBTEXAJCpDr0mwlw+AZyhu8iyC7R3S2vBwsI7QnWJU6X3WKc9VKeNEZpiMdZ569qWhz9574L3vV55qRL0Vtw==", + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.7", + "@vue/shared": "3.5.39", + "entities": "^7.0.1", + "estree-walker": "^2.0.2", + "source-map-js": "^1.2.1" + } + }, + "node_modules/@vue/compiler-dom": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.39.tgz", + "integrity": "sha512-oQPigALqYbNxTNPvNgSOe+czwVExfbVF02lz8jP0S3AXJiu3jxYDygNUiqSep4ezzW8XgnubqH63My2A7JR/vg==", + "license": "MIT", + "dependencies": { + "@vue/compiler-core": "3.5.39", + "@vue/shared": "3.5.39" + } + }, + "node_modules/@vue/compiler-sfc": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.39.tgz", + "integrity": "sha512-d0ki86iOyN8LoZPBmk5SJWNwHP19CnDDCfuo//+2WJa2g5Ke0Jay983PIBIcSSzldC68I8DrD5GrHV3OSDfodg==", + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.7", + "@vue/compiler-core": "3.5.39", + "@vue/compiler-dom": "3.5.39", + "@vue/compiler-ssr": "3.5.39", + "@vue/shared": "3.5.39", + "estree-walker": "^2.0.2", + "magic-string": "^0.30.21", + "postcss": "^8.5.15", + "source-map-js": "^1.2.1" + } + }, + "node_modules/@vue/compiler-ssr": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.39.tgz", + "integrity": "sha512-Ce7/wvwMHai74bdszfXExdazFigYnlF9zgCmEQUcM1j0fOymlouZ7XilTYNo8oUjhlnjYOZbGrcYKuqjz89Ucw==", + "license": "MIT", + "dependencies": { + "@vue/compiler-dom": "3.5.39", + "@vue/shared": "3.5.39" + } + }, + "node_modules/@vue/reactivity": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.39.tgz", + "integrity": "sha512-TpsuBJ9gGlZa5d23XcM2y8EXanz9dZeVDQBXRwzy46ItgvM+rWpzs+UVM0wcRLxGvcav0HE5jz2gNL53xlRAog==", + "license": "MIT", + "dependencies": { + "@vue/shared": "3.5.39" + } + }, + "node_modules/@vue/runtime-core": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.39.tgz", + "integrity": "sha512-9GLtNyRvPAUMbX+7ono0RC2j0guo2LXVi8LvcmAooImACUKm0oFf0jjwbX8/H0AE/t1nxhAkn8RSl9PMCzzxZw==", + "license": "MIT", + "dependencies": { + "@vue/reactivity": "3.5.39", + "@vue/shared": "3.5.39" + } + }, + "node_modules/@vue/runtime-dom": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.39.tgz", + "integrity": "sha512-7Y6aAGboKcXAZ3ECuUy7RrS5yy2r47dhTp2SKaJmYxjopImaVFaNa5Ne66NwGovsrxVAl5S5rwc7m22UG7Lmww==", + "license": "MIT", + "dependencies": { + "@vue/reactivity": "3.5.39", + "@vue/runtime-core": "3.5.39", + "@vue/shared": "3.5.39", + "csstype": "^3.2.3" + } + }, + "node_modules/@vue/server-renderer": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.39.tgz", + "integrity": "sha512-yZSakiAGw85rZfG7UM8akMnIF+FmeiNk47uvHf2nVBBSe+dIKUhZuZq9+XgJhbV3nS5Z4ALH23/MpXofW+mbcw==", + "license": "MIT", + "dependencies": { + "@vue/compiler-ssr": "3.5.39", + "@vue/shared": "3.5.39" + }, + "peerDependencies": { + "vue": "3.5.39" + } + }, + "node_modules/@vue/shared": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.39.tgz", + "integrity": "sha512-l1rrBtBfTnmxvtsvdQDXltUUy8S1Y+ZaqdfUzmAnJkTd8Z8rv5v/ytW+TKiqEOWyHPoqtPlNFSs0lhRmYVSHVA==", + "license": "MIT" + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "license": "MIT" + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/entities": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz", + "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", + "license": "MIT" + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/lightningcss": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz", + "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==", + "dev": true, + "license": "MPL-2.0", + "dependencies": { + "detect-libc": "^2.0.3" + }, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "lightningcss-android-arm64": "1.32.0", + "lightningcss-darwin-arm64": "1.32.0", + "lightningcss-darwin-x64": "1.32.0", + "lightningcss-freebsd-x64": "1.32.0", + "lightningcss-linux-arm-gnueabihf": "1.32.0", + "lightningcss-linux-arm64-gnu": "1.32.0", + "lightningcss-linux-arm64-musl": "1.32.0", + "lightningcss-linux-x64-gnu": "1.32.0", + "lightningcss-linux-x64-musl": "1.32.0", + "lightningcss-win32-arm64-msvc": "1.32.0", + "lightningcss-win32-x64-msvc": "1.32.0" + } + }, + "node_modules/lightningcss-linux-x64-gnu": { + "version": "1.32.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz", + "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/marked": { + "version": "18.0.5", + "resolved": "https://registry.npmjs.org/marked/-/marked-18.0.5.tgz", + "integrity": "sha512-S6GcvALHg6K4ohtu4E7x0a1AqhAjp6cV8KhLSyN9qVapnzJkusVBxZRcIU9AeYsbe6P1hKDusSbEOzGyyuce6w==", + "license": "MIT", + "bin": { + "marked": "bin/marked.js" + }, + "engines": { + "node": ">= 20" + } + }, + "node_modules/nanoid": { + "version": "3.3.15", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.15.tgz", + "integrity": "sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz", + "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.16", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.16.tgz", + "integrity": "sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.12", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/rolldown": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.1.5.tgz", + "integrity": "sha512-t9z29cJjXf/vxQ8dyhCSpt6H6aSwHTk8cT5I3iy6SMXuFpk5mB6PL6XfC8PCwrPTx93udwKUm9HRteAlTGBLiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@oxc-project/types": "=0.139.0", + "@rolldown/pluginutils": "^1.0.0" + }, + "bin": { + "rolldown": "bin/cli.mjs" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "optionalDependencies": { + "@rolldown/binding-android-arm64": "1.1.5", + "@rolldown/binding-darwin-arm64": "1.1.5", + "@rolldown/binding-darwin-x64": "1.1.5", + "@rolldown/binding-freebsd-x64": "1.1.5", + "@rolldown/binding-linux-arm-gnueabihf": "1.1.5", + "@rolldown/binding-linux-arm64-gnu": "1.1.5", + "@rolldown/binding-linux-arm64-musl": "1.1.5", + "@rolldown/binding-linux-ppc64-gnu": "1.1.5", + "@rolldown/binding-linux-s390x-gnu": "1.1.5", + "@rolldown/binding-linux-x64-gnu": "1.1.5", + "@rolldown/binding-linux-x64-musl": "1.1.5", + "@rolldown/binding-openharmony-arm64": "1.1.5", + "@rolldown/binding-wasm32-wasi": "1.1.5", + "@rolldown/binding-win32-arm64-msvc": "1.1.5", + "@rolldown/binding-win32-x64-msvc": "1.1.5" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/vite": { + "version": "8.1.4", + "resolved": "https://registry.npmjs.org/vite/-/vite-8.1.4.tgz", + "integrity": "sha512-bTT9PsdWO+MQMNG9ZXIP/qM9wGh37DFxTV/sPq9cFpHr3w4jkgef032PkAL9jAqhk3Nz8NQw3O8n6/xFkqO4QQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "lightningcss": "^1.32.0", + "picomatch": "^4.0.5", + "postcss": "^8.5.16", + "rolldown": "~1.1.4", + "tinyglobby": "^0.2.17" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "@vitejs/devtools": "^0.3.0", + "esbuild": "^0.27.0 || ^0.28.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "@vitejs/devtools": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vue": { + "version": "3.5.39", + "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.39.tgz", + "integrity": "sha512-xmZCYabFGcirU8r0fTuvl/LICc1OU620rnqepaJDL/a141ZigkG7AyaxQLdqJ02ZRYzWe6YPaDHeQx7MfknQfA==", + "license": "MIT", + "dependencies": { + "@vue/compiler-dom": "3.5.39", + "@vue/compiler-sfc": "3.5.39", + "@vue/runtime-dom": "3.5.39", + "@vue/server-renderer": "3.5.39", + "@vue/shared": "3.5.39" + }, + "peerDependencies": { + "typescript": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + } + } +} diff --git a/frontend/node_modules/.vite/deps/_metadata.json b/frontend/node_modules/.vite/deps/_metadata.json new file mode 100644 index 0000000..33206f3 --- /dev/null +++ b/frontend/node_modules/.vite/deps/_metadata.json @@ -0,0 +1,21 @@ +{ + "hash": "56f8b5bc", + "configHash": "ad91a1a3", + "lockfileHash": "85ee1cb2", + "browserHash": "8797f163", + "optimized": { + "marked": { + "src": "../../marked/lib/marked.esm.js", + "file": "marked.js", + "fileHash": "2600b6a1", + "needsInterop": false + }, + "vue": { + "src": "../../vue/dist/vue.runtime.esm-bundler.js", + "file": "vue.js", + "fileHash": "298c1225", + "needsInterop": false + } + }, + "chunks": {} +} \ No newline at end of file diff --git a/frontend/node_modules/.vite/deps/marked.js b/frontend/node_modules/.vite/deps/marked.js new file mode 100644 index 0000000..0f22035 --- /dev/null +++ b/frontend/node_modules/.vite/deps/marked.js @@ -0,0 +1,1610 @@ +//#region node_modules/marked/lib/marked.esm.js +/** +* marked v18.0.5 - a markdown parser +* Copyright (c) 2018-2026, MarkedJS. (MIT License) +* Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License) +* https://github.com/markedjs/marked +*/ +/** +* DO NOT EDIT THIS FILE +* The code in this file is generated from files in ./src/ +*/ +function M() { + return { + async: !1, + breaks: !1, + extensions: null, + gfm: !0, + hooks: null, + pedantic: !1, + renderer: null, + silent: !1, + tokenizer: null, + walkTokens: null + }; +} +var T = M(); +function N(l) { + T = l; +} +var _ = { exec: () => null }; +function E(l) { + let e = []; + return (t) => { + let n = Math.max(0, Math.min(3, t - 1)), s = e[n]; + return s || (s = l(n), e[n] = s), s; + }; +} +function d(l, e = "") { + let t = typeof l == "string" ? l : l.source, n = { + replace: (s, r) => { + let i = typeof r == "string" ? r : r.source; + return i = i.replace(m.caret, "$1"), t = t.replace(s, i), n; + }, + getRegex: () => new RegExp(t, e) + }; + return n; +} +var Te = ((l = "") => { + try { + return !!new RegExp("(?<=1)(?/, + blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, + blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, + listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, + listIsTask: /^\[[ xX]\] +\S/, + listReplaceTask: /^\[[ xX]\] +/, + listTaskCheckbox: /\[[ 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, + caret: /(^|[^\[])\^/g, + percentDecode: /%25/g, + findPipe: /\|/g, + splitPipe: / \|/, + slashPipe: /\\\|/g, + carriageReturn: /\r\n|\r/g, + spaceLine: /^ +$/gm, + notSpaceStart: /^\S*/, + endingNewline: /\n$/, + listItemRegex: (l) => new RegExp(`^( {0,3}${l})((?:[ ][^\\n]*)?(?:\\n|$))`), + nextBulletRegex: E((l) => new RegExp(`^ {0,${l}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`)), + hrRegex: E((l) => new RegExp(`^ {0,${l}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`)), + fencesBeginRegex: E((l) => new RegExp(`^ {0,${l}}(?:\`\`\`|~~~)`)), + headingBeginRegex: E((l) => new RegExp(`^ {0,${l}}#`)), + htmlBeginRegex: E((l) => new RegExp(`^ {0,${l}}<(?:[a-z].*>|!--)`, "i")), + blockquoteBeginRegex: E((l) => new RegExp(`^ {0,${l}}>`)) +}; +var Oe = /^(?:[ \t]*(?:\n|$))+/; +var we = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/; +var ye = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/; +var B = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/; +var Pe = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/; +var j = / {0,3}(?:[*+-]|\d{1,9}[.)])/; +var oe = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/; +var ae = d(oe).replace(/bull/g, j).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(); +var Se = d(oe).replace(/bull/g, j).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(); +var F = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/; +var $e = /^[^\n]+/; +var U = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/; +var Le = d(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", U).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(); +var _e = d(/^(bull)([ \t][^\n]*?)?(?:\n|$)/).replace(/bull/g, j).getRegex(); +var H = "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"; +var K = /|$))/; +var ze = d("^ {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", K).replace("tag", H).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(); +var le = d(F).replace("hr", B).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[.)])[ \\t]+[^ \\t\\n]").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", H).getRegex(); +var W = { + blockquote: d(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", le).getRegex(), + code: we, + def: Le, + fences: ye, + heading: Pe, + hr: B, + html: ze, + lheading: ae, + list: _e, + newline: Oe, + paragraph: le, + table: _, + text: $e +}; +var se = d("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", B).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[.)])[ \\t]").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", H).getRegex(); +var Ee = { + ...W, + lheading: Se, + table: se, + paragraph: d(F).replace("hr", B).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", se).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", H).getRegex() +}; +var Ie = { + ...W, + html: d(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", K).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: _, + lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, + paragraph: d(F).replace("hr", B).replace("heading", ` *#{1,6} *[^ +]`).replace("lheading", ae).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() +}; +var Ae = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/; +var Ce = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/; +var ue = /^( {2,}|\\)\n(?!\s*$)/; +var Be = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\`+)[^`]+\k(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-", Te ? "(?`+)[^`]+\k(?!`)/).replace("html", /<(?! )[^<>]*?>/).getRegex(); +var ce = /^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/; +var Ze = d(ce, "u").replace(/punct/g, I).getRegex(); +var Ge = d(ce, "u").replace(/punct/g, pe).getRegex(); +var he = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)"; +var Ne = d(he, "gu").replace(/notPunctSpace/g, X).replace(/punctSpace/g, Z).replace(/punct/g, I).getRegex(); +var Qe = d(he, "gu").replace(/notPunctSpace/g, ve).replace(/punctSpace/g, qe).replace(/punct/g, pe).getRegex(); +var je = d("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, X).replace(/punctSpace/g, Z).replace(/punct/g, I).getRegex(); +var Fe = d(/^~~?(?:((?!~)punct)|[^\s~])/, "u").replace(/punct/g, I).getRegex(); +var Ke = d("^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)", "gu").replace(/notPunctSpace/g, X).replace(/punctSpace/g, Z).replace(/punct/g, I).getRegex(); +var We = d(/\\(punct)/, "gu").replace(/punct/g, I).getRegex(); +var Xe = d(/^<(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(); +var Je = d(K).replace("(?:-->|$)", "-->").getRegex(); +var Ve = d("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment", Je).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(); +var v = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/; +var Ye = d(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label", v).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(); +var ke = d(/^!?\[(label)\]\[(ref)\]/).replace("label", v).replace("ref", U).getRegex(); +var de = d(/^!?\[(ref)\](?:\[\])?/).replace("ref", U).getRegex(); +var et = d("reflink|nolink(?!\\()", "g").replace("reflink", ke).replace("nolink", de).getRegex(); +var ie = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/; +var J = { + _backpedal: _, + anyPunctuation: We, + autolink: Xe, + blockSkip: He, + br: ue, + code: Ce, + del: _, + delLDelim: _, + delRDelim: _, + emStrongLDelim: Ze, + emStrongRDelimAst: Ne, + emStrongRDelimUnd: je, + escape: Ae, + link: Ye, + nolink: de, + punctuation: De, + reflink: ke, + reflinkSearch: et, + tag: Ve, + text: Be, + url: _ +}; +var tt = { + ...J, + link: d(/^!?\[(label)\]\((.*?)\)/).replace("label", v).getRegex(), + reflink: d(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", v).getRegex() +}; +var Q = { + ...J, + emStrongRDelimAst: Qe, + emStrongLDelim: Ge, + delLDelim: Fe, + delRDelim: Ke, + url: d(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol", ie).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\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, + text: d(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\": ">", + "\"": """, + "'": "'" +}; +var ge = (l) => rt[l]; +function O(l, e) { + if (e) { + if (m.escapeTest.test(l)) return l.replace(m.escapeReplace, ge); + } else if (m.escapeTestNoEncode.test(l)) return l.replace(m.escapeReplaceNoEncode, ge); + return l; +} +function V(l) { + try { + l = encodeURI(l).replace(m.percentDecode, "%"); + } catch { + return null; + } + return l; +} +function Y(l, e) { + let n = l.replace(m.findPipe, (r, i, o) => { + let u = !1, a = i; + for (; --a >= 0 && o[a] === "\\";) u = !u; + return u ? "|" : " |"; + }).split(m.splitPipe), s = 0; + if (n[0].trim() || n.shift(), n.length > 0 && !n.at(-1)?.trim() && n.pop(), e) if (n.length > e) n.splice(e); + else for (; n.length < e;) n.push(""); + for (; s < n.length; s++) n[s] = n[s].trim().replace(m.slashPipe, "|"); + return n; +} +function $(l, e, t) { + let n = l.length; + if (n === 0) return ""; + let s = 0; + for (; s < n;) { + let r = l.charAt(n - s - 1); + if (r === e && !t) s++; + else if (r !== e && t) s++; + else break; + } + return l.slice(0, n - s); +} +function ee(l) { + let e = l.split(` +`), t = e.length - 1; + for (; t >= 0 && m.blankLine.test(e[t]);) t--; + return e.length - t <= 2 ? l : e.slice(0, t + 1).join(` +`); +} +function fe(l, e) { + if (l.indexOf(e[1]) === -1) return -1; + let t = 0; + for (let n = 0; n < l.length; n++) if (l[n] === "\\") n++; + else if (l[n] === e[0]) t++; + else if (l[n] === e[1] && (t--, t < 0)) return n; + return t > 0 ? -2 : -1; +} +function me(l, e = 0) { + let t = e, n = ""; + for (let s of l) if (s === " ") { + let r = 4 - t % 4; + n += " ".repeat(r), t += r; + } else n += s, t++; + return n; +} +function xe(l, e, t, n, s) { + let r = e.href, i = e.title || null, o = l[1].replace(s.other.outputLinkReplace, "$1"); + n.state.inLink = !0; + let u = { + type: l[0].charAt(0) === "!" ? "image" : "link", + raw: t, + href: r, + title: i, + text: o, + tokens: n.inlineTokens(o) + }; + return n.state.inLink = !1, u; +} +function st(l, e, t) { + let n = l.match(t.other.indentCodeCompensation); + if (n === null) return e; + let s = n[1]; + return e.split(` +`).map((r) => { + let i = r.match(t.other.beginningSpace); + if (i === null) return r; + let [o] = i; + return o.length >= s.length ? r.slice(s.length) : r; + }).join(` +`); +} +var w = class { + options; + rules; + lexer; + constructor(e) { + this.options = e || T; + } + space(e) { + let t = this.rules.block.newline.exec(e); + if (t && t[0].length > 0) return { + type: "space", + raw: t[0] + }; + } + code(e) { + let t = this.rules.block.code.exec(e); + if (t) { + let n = this.options.pedantic ? t[0] : ee(t[0]); + return { + type: "code", + raw: n, + codeBlockStyle: "indented", + text: n.replace(this.rules.other.codeRemoveIndent, "") + }; + } + } + fences(e) { + let t = this.rules.block.fences.exec(e); + if (t) { + let n = t[0], s = st(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: s + }; + } + } + heading(e) { + let t = this.rules.block.heading.exec(e); + if (t) { + let n = t[2].trim(); + if (this.rules.other.endingHash.test(n)) { + let s = $(n, "#"); + (this.options.pedantic || !s || this.rules.other.endingSpaceChar.test(s)) && (n = s.trim()); + } + return { + type: "heading", + raw: $(t[0], ` +`), + depth: t[1].length, + text: n, + tokens: this.lexer.inline(n) + }; + } + } + hr(e) { + let t = this.rules.block.hr.exec(e); + if (t) return { + type: "hr", + raw: $(t[0], ` +`) + }; + } + blockquote(e) { + let t = this.rules.block.blockquote.exec(e); + if (t) { + let n = $(t[0], ` +`).split(` +`), s = "", r = "", i = []; + for (; n.length > 0;) { + let o = !1, u = [], a; + for (a = 0; a < n.length; a++) if (this.rules.other.blockquoteStart.test(n[a])) u.push(n[a]), o = !0; + else if (!o) u.push(n[a]); + else break; + n = n.slice(a); + let c = u.join(` +`), p = c.replace(this.rules.other.blockquoteSetextReplace, ` + $1`).replace(this.rules.other.blockquoteSetextReplace2, ""); + s = s ? `${s} +${c}` : c, r = r ? `${r} +${p}` : p; + let k = this.lexer.state.top; + if (this.lexer.state.top = !0, this.lexer.blockTokens(p, i, !0), this.lexer.state.top = k, n.length === 0) break; + let h = i.at(-1); + if (h?.type === "code") break; + if (h?.type === "blockquote") { + let R = h, f = R.raw + ` +` + n.join(` +`), S = this.blockquote(f); + i[i.length - 1] = S, s = s.substring(0, s.length - R.raw.length) + S.raw, r = r.substring(0, r.length - R.text.length) + S.text; + break; + } else if (h?.type === "list") { + let R = h, f = R.raw + ` +` + n.join(` +`), S = this.list(f); + i[i.length - 1] = S, s = s.substring(0, s.length - h.raw.length) + S.raw, r = r.substring(0, r.length - R.raw.length) + S.raw, n = f.substring(i.at(-1).raw.length).split(` +`); + continue; + } + } + return { + type: "blockquote", + raw: s, + tokens: i, + text: r + }; + } + } + list(e) { + let t = this.rules.block.list.exec(e); + if (t) { + let n = t[1].trim(), s = n.length > 1, r = { + type: "list", + raw: "", + ordered: s, + start: s ? +n.slice(0, -1) : "", + loose: !1, + items: [] + }; + n = s ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = s ? n : "[*+-]"); + let i = this.rules.other.listItemRegex(n), o = !1; + for (; e;) { + let a = !1, c = "", p = ""; + if (!(t = i.exec(e)) || this.rules.block.hr.test(e)) break; + c = t[0], e = e.substring(c.length); + let k = me(t[2].split(` +`, 1)[0], t[1].length), h = e.split(` +`, 1)[0], R = !k.trim(), f = 0; + if (this.options.pedantic ? (f = 2, p = k.trimStart()) : R ? f = t[1].length + 1 : (f = k.search(this.rules.other.nonSpaceChar), f = f > 4 ? 1 : f, p = k.slice(f), f += t[1].length), R && this.rules.other.blankLine.test(h) && (c += h + ` +`, e = e.substring(h.length + 1), a = !0), !a) { + let S = this.rules.other.nextBulletRegex(f), te = this.rules.other.hrRegex(f), ne = this.rules.other.fencesBeginRegex(f), re = this.rules.other.headingBeginRegex(f), be = this.rules.other.htmlBeginRegex(f), Re = this.rules.other.blockquoteBeginRegex(f); + for (; e;) { + let G = e.split(` +`, 1)[0], C; + if (h = G, this.options.pedantic ? (h = h.replace(this.rules.other.listReplaceNesting, " "), C = h) : C = h.replace(this.rules.other.tabCharGlobal, " "), ne.test(h) || re.test(h) || be.test(h) || Re.test(h) || S.test(h) || te.test(h)) break; + if (C.search(this.rules.other.nonSpaceChar) >= f || !h.trim()) p += ` +` + C.slice(f); + else { + if (R || k.replace(this.rules.other.tabCharGlobal, " ").search(this.rules.other.nonSpaceChar) >= 4 || ne.test(k) || re.test(k) || te.test(k)) break; + p += ` +` + h; + } + R = !h.trim(), c += G + ` +`, e = e.substring(G.length + 1), k = C.slice(f); + } + } + r.loose || (o ? r.loose = !0 : this.rules.other.doubleBlankLine.test(c) && (o = !0)), r.items.push({ + type: "list_item", + raw: c, + task: !!this.options.gfm && this.rules.other.listIsTask.test(p), + loose: !1, + text: p, + tokens: [] + }), r.raw += c; + } + let u = r.items.at(-1); + if (u) u.raw = u.raw.trimEnd(), u.text = u.text.trimEnd(); + else return; + r.raw = r.raw.trimEnd(); + for (let a of r.items) { + this.lexer.state.top = !1, a.tokens = this.lexer.blockTokens(a.text, []); + let c = a.tokens[0]; + if (a.task && (c?.type === "text" || c?.type === "paragraph")) { + a.text = a.text.replace(this.rules.other.listReplaceTask, ""), c.raw = c.raw.replace(this.rules.other.listReplaceTask, ""), c.text = c.text.replace(this.rules.other.listReplaceTask, ""); + for (let k = this.lexer.inlineQueue.length - 1; k >= 0; k--) if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[k].src)) { + this.lexer.inlineQueue[k].src = this.lexer.inlineQueue[k].src.replace(this.rules.other.listReplaceTask, ""); + break; + } + let p = this.rules.other.listTaskCheckbox.exec(a.raw); + if (p) { + let k = { + type: "checkbox", + raw: p[0] + " ", + checked: p[0] !== "[ ]" + }; + a.checked = k.checked, r.loose ? a.tokens[0] && ["paragraph", "text"].includes(a.tokens[0].type) && "tokens" in a.tokens[0] && a.tokens[0].tokens ? (a.tokens[0].raw = k.raw + a.tokens[0].raw, a.tokens[0].text = k.raw + a.tokens[0].text, a.tokens[0].tokens.unshift(k)) : a.tokens.unshift({ + type: "paragraph", + raw: k.raw, + text: k.raw, + tokens: [k] + }) : a.tokens.unshift(k); + } + } else a.task && (a.task = !1); + if (!r.loose) { + let p = a.tokens.filter((h) => h.type === "space"); + r.loose = p.length > 0 && p.some((h) => this.rules.other.anyLine.test(h.raw)); + } + } + if (r.loose) for (let a of r.items) { + a.loose = !0; + for (let c of a.tokens) c.type === "text" && (c.type = "paragraph"); + } + return r; + } + } + html(e) { + let t = this.rules.block.html.exec(e); + if (t) { + let n = ee(t[0]); + return { + type: "html", + block: !0, + raw: n, + pre: t[1] === "pre" || t[1] === "script" || t[1] === "style", + text: n + }; + } + } + def(e) { + let t = this.rules.block.def.exec(e); + if (t) { + let n = t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), s = t[2] ? t[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", r = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3]; + return { + type: "def", + tag: n, + raw: $(t[0], ` +`), + href: s, + title: r + }; + } + } + table(e) { + let t = this.rules.block.table.exec(e); + if (!t || !this.rules.other.tableDelimiter.test(t[2])) return; + let n = Y(t[1]), s = t[2].replace(this.rules.other.tableAlignChars, "").split("|"), r = t[3]?.trim() ? t[3].replace(this.rules.other.tableRowBlankLine, "").split(` +`) : [], i = { + type: "table", + raw: $(t[0], ` +`), + header: [], + align: [], + rows: [] + }; + if (n.length === s.length) { + for (let o of s) this.rules.other.tableAlignRight.test(o) ? i.align.push("right") : this.rules.other.tableAlignCenter.test(o) ? i.align.push("center") : this.rules.other.tableAlignLeft.test(o) ? i.align.push("left") : i.align.push(null); + for (let o = 0; o < n.length; o++) i.header.push({ + text: n[o], + tokens: this.lexer.inline(n[o]), + header: !0, + align: i.align[o] + }); + for (let o of r) i.rows.push(Y(o, i.header.length).map((u, a) => ({ + text: u, + tokens: this.lexer.inline(u), + header: !1, + align: i.align[a] + }))); + return i; + } + } + lheading(e) { + let t = this.rules.block.lheading.exec(e); + if (t) { + let n = t[1].trim(); + return { + type: "heading", + raw: $(t[0], ` +`), + depth: t[2].charAt(0) === "=" ? 1 : 2, + text: n, + tokens: this.lexer.inline(n) + }; + } + } + paragraph(e) { + let t = this.rules.block.paragraph.exec(e); + if (t) { + let 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) { + let 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) { + let t = this.rules.inline.escape.exec(e); + if (t) return { + type: "escape", + raw: t[0], + text: t[1] + }; + } + tag(e) { + let 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) { + let t = this.rules.inline.link.exec(e); + if (t) { + let n = t[2].trim(); + if (!this.options.pedantic && this.rules.other.startAngleBracket.test(n)) { + if (!this.rules.other.endAngleBracket.test(n)) return; + let i = $(n.slice(0, -1), "\\"); + if ((n.length - i.length) % 2 === 0) return; + } else { + let i = fe(t[2], "()"); + if (i === -2) return; + if (i > -1) { + let u = (t[0].indexOf("!") === 0 ? 5 : 4) + t[1].length + i; + t[2] = t[2].substring(0, i), t[0] = t[0].substring(0, u).trim(), t[3] = ""; + } + } + let s = t[2], r = ""; + if (this.options.pedantic) { + let i = this.rules.other.pedanticHrefTitle.exec(s); + i && (s = i[1], r = i[3]); + } else r = t[3] ? t[3].slice(1, -1) : ""; + return s = s.trim(), this.rules.other.startAngleBracket.test(s) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(n) ? s = s.slice(1) : s = s.slice(1, -1)), xe(t, { + href: s && s.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))) { + let r = t[(n[2] || n[1]).replace(this.rules.other.multipleSpaceGlobal, " ").toLowerCase()]; + if (!r) { + let i = n[0].charAt(0); + return { + type: "text", + raw: i, + text: i + }; + } + return xe(n, r, n[0], this.lexer, this.rules); + } + } + emStrong(e, t, n = "") { + let s = this.rules.inline.emStrongLDelim.exec(e); + if (!s || !s[1] && !s[2] && !s[3] && !s[4] || s[4] && n.match(this.rules.other.unicodeAlphaNumeric)) return; + if (!(s[1] || s[3] || "") || !n || this.rules.inline.punctuation.exec(n)) { + let i = [...s[0]].length - 1, o, u, a = i, c = 0, p = s[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd; + for (p.lastIndex = 0, t = t.slice(-1 * e.length + i); (s = p.exec(t)) !== null;) { + if (o = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !o) continue; + if (u = [...o].length, s[3] || s[4]) { + a += u; + continue; + } else if ((s[5] || s[6]) && i % 3 && !((i + u) % 3)) { + c += u; + continue; + } + if (a -= u, a > 0) continue; + u = Math.min(u, u + a + c); + let k = [...s[0]][0].length, h = e.slice(0, i + s.index + k + u); + if (Math.min(i, u) % 2) { + let f = h.slice(1, -1); + return { + type: "em", + raw: h, + text: f, + tokens: this.lexer.inlineTokens(f) + }; + } + let R = h.slice(2, -2); + return { + type: "strong", + raw: h, + text: R, + tokens: this.lexer.inlineTokens(R) + }; + } + } + } + codespan(e) { + let t = this.rules.inline.code.exec(e); + if (t) { + let n = t[2].replace(this.rules.other.newLineCharGlobal, " "), s = this.rules.other.nonSpaceChar.test(n), r = this.rules.other.startingSpaceChar.test(n) && this.rules.other.endingSpaceChar.test(n); + return s && r && (n = n.substring(1, n.length - 1)), { + type: "codespan", + raw: t[0], + text: n + }; + } + } + br(e) { + let t = this.rules.inline.br.exec(e); + if (t) return { + type: "br", + raw: t[0] + }; + } + del(e, t, n = "") { + let s = this.rules.inline.delLDelim.exec(e); + if (!s) return; + if (!(s[1] || "") || !n || this.rules.inline.punctuation.exec(n)) { + let i = [...s[0]].length - 1, o, u, a = i, c = this.rules.inline.delRDelim; + for (c.lastIndex = 0, t = t.slice(-1 * e.length + i); (s = c.exec(t)) !== null;) { + if (o = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !o || (u = [...o].length, u !== i)) continue; + if (s[3] || s[4]) { + a += u; + continue; + } + if (a -= u, a > 0) continue; + u = Math.min(u, u + a); + let p = [...s[0]][0].length, k = e.slice(0, i + s.index + p + u), h = k.slice(i, -i); + return { + type: "del", + raw: k, + text: h, + tokens: this.lexer.inlineTokens(h) + }; + } + } + } + autolink(e) { + let t = this.rules.inline.autolink.exec(e); + if (t) { + let n, s; + return t[2] === "@" ? (n = t[1], s = "mailto:" + n) : (n = t[1], s = n), { + type: "link", + raw: t[0], + text: n, + href: s, + tokens: [{ + type: "text", + raw: n, + text: n + }] + }; + } + } + url(e) { + let t; + if (t = this.rules.inline.url.exec(e)) { + let n, s; + if (t[2] === "@") n = t[0], s = "mailto:" + n; + else { + let r; + do + r = t[0], t[0] = this.rules.inline._backpedal.exec(t[0])?.[0] ?? ""; + while (r !== t[0]); + n = t[0], t[1] === "www." ? s = "http://" + t[0] : s = t[0]; + } + return { + type: "link", + raw: t[0], + text: n, + href: s, + tokens: [{ + type: "text", + raw: n, + text: n + }] + }; + } + } + inlineText(e) { + let t = this.rules.inline.text.exec(e); + if (t) { + let n = this.lexer.state.inRawBlock; + return { + type: "text", + raw: t[0], + text: t[0], + escaped: n + }; + } + } +}; +var x = class l { + tokens; + options; + state; + inlineQueue; + tokenizer; + constructor(e) { + this.tokens = [], this.tokens.links = Object.create(null), this.options = e || T, this.options.tokenizer = this.options.tokenizer || new w(), this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { + inLink: !1, + inRawBlock: !1, + top: !0 + }; + let t = { + other: m, + block: D.normal, + inline: A.normal + }; + this.options.pedantic ? (t.block = D.pedantic, t.inline = A.pedantic) : this.options.gfm && (t.block = D.gfm, this.options.breaks ? t.inline = A.breaks : t.inline = A.gfm), this.tokenizer.rules = t; + } + static get rules() { + return { + block: D, + inline: A + }; + } + static lex(e, t) { + return new l(t).lex(e); + } + static lexInline(e, t) { + return new l(t).inlineTokens(e); + } + lex(e) { + e = e.replace(m.carriageReturn, ` +`), this.blockTokens(e, this.tokens); + for (let t = 0; t < this.inlineQueue.length; t++) { + let n = this.inlineQueue[t]; + this.inlineTokens(n.src, n.tokens); + } + return this.inlineQueue = [], this.tokens; + } + blockTokens(e, t = [], n = !1) { + this.tokenizer.lexer = this, this.options.pedantic && (e = e.replace(m.tabCharGlobal, " ").replace(m.spaceLine, "")); + let s = Infinity; + for (; e;) { + if (e.length < s) s = e.length; + else { + this.infiniteLoopError(e.charCodeAt(0)); + break; + } + let r; + if (this.options.extensions?.block?.some((o) => (r = o.call({ lexer: this }, e, t)) ? (e = e.substring(r.raw.length), t.push(r), !0) : !1)) continue; + if (r = this.tokenizer.space(e)) { + e = e.substring(r.raw.length); + let o = t.at(-1); + r.raw.length === 1 && o !== void 0 ? o.raw += ` +` : t.push(r); + continue; + } + if (r = this.tokenizer.code(e)) { + e = e.substring(r.raw.length); + let o = t.at(-1); + o?.type === "paragraph" || o?.type === "text" ? (o.raw += (o.raw.endsWith(` +`) ? "" : ` +`) + r.raw, o.text += ` +` + r.text, this.inlineQueue.at(-1).src = o.text) : t.push(r); + continue; + } + if (r = this.tokenizer.fences(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.heading(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.hr(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.blockquote(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.list(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.html(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.def(e)) { + e = e.substring(r.raw.length); + let o = t.at(-1); + o?.type === "paragraph" || o?.type === "text" ? (o.raw += (o.raw.endsWith(` +`) ? "" : ` +`) + r.raw, o.text += ` +` + r.raw, this.inlineQueue.at(-1).src = o.text) : this.tokens.links[r.tag] || (this.tokens.links[r.tag] = { + href: r.href, + title: r.title + }, t.push(r)); + continue; + } + if (r = this.tokenizer.table(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + if (r = this.tokenizer.lheading(e)) { + e = e.substring(r.raw.length), t.push(r); + continue; + } + let i = e; + if (this.options.extensions?.startBlock) { + let o = Infinity, u = e.slice(1), a; + this.options.extensions.startBlock.forEach((c) => { + a = c.call({ lexer: this }, u), typeof a == "number" && a >= 0 && (o = Math.min(o, a)); + }), o < Infinity && o >= 0 && (i = e.substring(0, o + 1)); + } + if (this.state.top && (r = this.tokenizer.paragraph(i))) { + let o = t.at(-1); + n && o?.type === "paragraph" ? (o.raw += (o.raw.endsWith(` +`) ? "" : ` +`) + r.raw, o.text += ` +` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = o.text) : t.push(r), n = i.length !== e.length, e = e.substring(r.raw.length); + continue; + } + if (r = this.tokenizer.text(e)) { + e = e.substring(r.raw.length); + let o = t.at(-1); + o?.type === "text" ? (o.raw += (o.raw.endsWith(` +`) ? "" : ` +`) + r.raw, o.text += ` +` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = o.text) : t.push(r); + continue; + } + if (e) { + this.infiniteLoopError(e.charCodeAt(0)); + break; + } + } + return this.state.top = !0, t; + } + inline(e, t = []) { + return this.inlineQueue.push({ + src: e, + tokens: t + }), t; + } + inlineTokens(e, t = []) { + this.tokenizer.lexer = this; + let n = e, s = null; + if (this.tokens.links) { + let a = Object.keys(this.tokens.links); + if (a.length > 0) for (; (s = this.tokenizer.rules.inline.reflinkSearch.exec(n)) !== null;) a.includes(s[0].slice(s[0].lastIndexOf("[") + 1, -1)) && (n = n.slice(0, s.index) + "[" + "a".repeat(s[0].length - 2) + "]" + n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex)); + } + for (; (s = this.tokenizer.rules.inline.anyPunctuation.exec(n)) !== null;) n = n.slice(0, s.index) + "++" + n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex); + let r; + for (; (s = this.tokenizer.rules.inline.blockSkip.exec(n)) !== null;) r = s[2] ? s[2].length : 0, n = n.slice(0, s.index + r) + "[" + "a".repeat(s[0].length - r - 2) + "]" + n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex); + n = this.options.hooks?.emStrongMask?.call({ lexer: this }, n) ?? n; + let i = !1, o = "", u = Infinity; + for (; e;) { + if (e.length < u) u = e.length; + else { + this.infiniteLoopError(e.charCodeAt(0)); + break; + } + i || (o = ""), i = !1; + let a; + if (this.options.extensions?.inline?.some((p) => (a = p.call({ lexer: this }, e, t)) ? (e = e.substring(a.raw.length), t.push(a), !0) : !1)) continue; + if (a = this.tokenizer.escape(e)) { + e = e.substring(a.raw.length), t.push(a); + continue; + } + if (a = this.tokenizer.tag(e)) { + e = e.substring(a.raw.length), t.push(a); + continue; + } + if (a = this.tokenizer.link(e)) { + e = e.substring(a.raw.length), t.push(a); + continue; + } + if (a = this.tokenizer.reflink(e, this.tokens.links)) { + e = e.substring(a.raw.length); + let p = t.at(-1); + a.type === "text" && p?.type === "text" ? (p.raw += a.raw, p.text += a.text) : t.push(a); + continue; + } + if (a = this.tokenizer.emStrong(e, n, o)) { + e = e.substring(a.raw.length), t.push(a); + continue; + } + if (a = this.tokenizer.codespan(e)) { + e = e.substring(a.raw.length), t.push(a); + continue; + } + if (a = this.tokenizer.br(e)) { + e = e.substring(a.raw.length), t.push(a); + continue; + } + if (a = this.tokenizer.del(e, n, o)) { + e = e.substring(a.raw.length), t.push(a); + continue; + } + if (a = this.tokenizer.autolink(e)) { + e = e.substring(a.raw.length), t.push(a); + continue; + } + if (!this.state.inLink && (a = this.tokenizer.url(e))) { + e = e.substring(a.raw.length), t.push(a); + continue; + } + let c = e; + if (this.options.extensions?.startInline) { + let p = Infinity, k = e.slice(1), h; + this.options.extensions.startInline.forEach((R) => { + h = R.call({ lexer: this }, k), typeof h == "number" && h >= 0 && (p = Math.min(p, h)); + }), p < Infinity && p >= 0 && (c = e.substring(0, p + 1)); + } + if (a = this.tokenizer.inlineText(c)) { + e = e.substring(a.raw.length), a.raw.slice(-1) !== "_" && (o = a.raw.slice(-1)), i = !0; + let p = t.at(-1); + p?.type === "text" ? (p.raw += a.raw, p.text += a.text) : t.push(a); + continue; + } + if (e) { + this.infiniteLoopError(e.charCodeAt(0)); + break; + } + } + return t; + } + infiniteLoopError(e) { + let t = "Infinite loop on byte: " + e; + if (this.options.silent) console.error(t); + else throw new Error(t); + } +}; +var y = class { + options; + parser; + constructor(e) { + this.options = e || T; + } + space(e) { + return ""; + } + code({ text: e, lang: t, escaped: n }) { + let s = (t || "").match(m.notSpaceStart)?.[0], r = e.replace(m.endingNewline, "") + ` +`; + return s ? "
    " + (n ? r : O(r, !0)) + `
    +` : "
    " + (n ? r : O(r, !0)) + `
    +`; + } + blockquote({ tokens: e }) { + return `
    +${this.parser.parse(e)}
    +`; + } + html({ text: e }) { + return e; + } + def(e) { + return ""; + } + heading({ tokens: e, depth: t }) { + return `${this.parser.parseInline(e)} +`; + } + hr(e) { + return `
    +`; + } + list(e) { + let t = e.ordered, n = e.start, s = ""; + for (let o = 0; o < e.items.length; o++) { + let u = e.items[o]; + s += this.listitem(u); + } + let r = t ? "ol" : "ul", i = t && n !== 1 ? " start=\"" + n + "\"" : ""; + return "<" + r + i + `> +` + s + " +`; + } + listitem(e) { + return `
  • ${this.parser.parse(e.tokens)}
    • +`; + } + checkbox({ checked: e }) { + return " "; + } + paragraph({ tokens: e }) { + return `

    ${this.parser.parseInline(e)}

    +`; + } + table(e) { + let t = "", n = ""; + for (let r = 0; r < e.header.length; r++) n += this.tablecell(e.header[r]); + t += this.tablerow({ text: n }); + let s = ""; + for (let r = 0; r < e.rows.length; r++) { + let i = e.rows[r]; + n = ""; + for (let o = 0; o < i.length; o++) n += this.tablecell(i[o]); + s += this.tablerow({ text: n }); + } + return s && (s = `${s}`), ` + +` + t + ` +` + s + `
    +`; + } + tablerow({ text: e }) { + return ` +${e} +`; + } + tablecell(e) { + let 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 `${O(e, !0)}`; + } + br(e) { + return "
    "; + } + del({ tokens: e }) { + return `${this.parser.parseInline(e)}`; + } + link({ href: e, title: t, tokens: n }) { + let s = this.parser.parseInline(n), r = V(e); + if (r === null) return s; + e = r; + let i = "    ", i; + } + image({ href: e, title: t, text: n, tokens: s }) { + s && (n = this.parser.parseInline(s, this.parser.textRenderer)); + let r = V(e); + if (r === null) return O(n); + e = r; + let i = `${O(n)} { + let o = r[i].flat(Infinity); + n = n.concat(this.walkTokens(o, t)); + }) : r.tokens && (n = n.concat(this.walkTokens(r.tokens, t))); + } + } + return n; + } + use(...e) { + let t = this.defaults.extensions || { + renderers: {}, + childTokens: {} + }; + return e.forEach((n) => { + let s = { ...n }; + if (s.async = this.defaults.async || s.async || !1, n.extensions && (n.extensions.forEach((r) => { + if (!r.name) throw new Error("extension name required"); + if ("renderer" in r) { + let i = t.renderers[r.name]; + i ? t.renderers[r.name] = function(...o) { + let u = r.renderer.apply(this, o); + return u === !1 && (u = i.apply(this, o)), u; + } : 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'"); + let 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); + }), s.extensions = t), n.renderer) { + let r = this.defaults.renderer || new y(this.defaults); + for (let i in n.renderer) { + if (!(i in r)) throw new Error(`renderer '${i}' does not exist`); + if (["options", "parser"].includes(i)) continue; + let o = i, u = n.renderer[o], a = r[o]; + r[o] = (...c) => { + let p = u.apply(r, c); + return p === !1 && (p = a.apply(r, c)), p || ""; + }; + } + s.renderer = r; + } + if (n.tokenizer) { + let r = this.defaults.tokenizer || new w(this.defaults); + for (let i in n.tokenizer) { + if (!(i in r)) throw new Error(`tokenizer '${i}' does not exist`); + if ([ + "options", + "rules", + "lexer" + ].includes(i)) continue; + let o = i, u = n.tokenizer[o], a = r[o]; + r[o] = (...c) => { + let p = u.apply(r, c); + return p === !1 && (p = a.apply(r, c)), p; + }; + } + s.tokenizer = r; + } + if (n.hooks) { + let r = this.defaults.hooks || new P(); + for (let i in n.hooks) { + if (!(i in r)) throw new Error(`hook '${i}' does not exist`); + if (["options", "block"].includes(i)) continue; + let o = i, u = n.hooks[o], a = r[o]; + P.passThroughHooks.has(i) ? r[o] = (c) => { + if (this.defaults.async && P.passThroughHooksRespectAsync.has(i)) return (async () => { + let k = await u.call(r, c); + return a.call(r, k); + })(); + let p = u.call(r, c); + return a.call(r, p); + } : r[o] = (...c) => { + if (this.defaults.async) return (async () => { + let k = await u.apply(r, c); + return k === !1 && (k = await a.apply(r, c)), k; + })(); + let p = u.apply(r, c); + return p === !1 && (p = a.apply(r, c)), p; + }; + } + s.hooks = r; + } + if (n.walkTokens) { + let r = this.defaults.walkTokens, i = n.walkTokens; + s.walkTokens = function(o) { + let u = []; + return u.push(i.call(this, o)), r && (u = u.concat(r.call(this, o))), u; + }; + } + this.defaults = { + ...this.defaults, + ...s + }; + }), this; + } + setOptions(e) { + return this.defaults = { + ...this.defaults, + ...e + }, this; + } + lexer(e, t) { + return x.lex(e, t ?? this.defaults); + } + parser(e, t) { + return b.parse(e, t ?? this.defaults); + } + parseMarkdown(e) { + return (n, s) => { + let r = { ...s }, i = { + ...this.defaults, + ...r + }, o = this.onError(!!i.silent, !!i.async); + if (this.defaults.async === !0 && r.async === !1) return o(/* @__PURE__ */ 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(/* @__PURE__ */ new Error("marked(): input parameter is undefined or null")); + if (typeof n != "string") return o(/* @__PURE__ */ new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n) + ", string expected")); + if (i.hooks && (i.hooks.options = i, i.hooks.block = e), i.async) return (async () => { + let u = i.hooks ? await i.hooks.preprocess(n) : n, c = await (i.hooks ? await i.hooks.provideLexer(e) : e ? x.lex : x.lexInline)(u, i), p = i.hooks ? await i.hooks.processAllTokens(c) : c; + i.walkTokens && await Promise.all(this.walkTokens(p, i.walkTokens)); + let h = await (i.hooks ? await i.hooks.provideParser(e) : e ? b.parse : b.parseInline)(p, i); + return i.hooks ? await i.hooks.postprocess(h) : h; + })().catch(o); + try { + i.hooks && (n = i.hooks.preprocess(n)); + let a = (i.hooks ? i.hooks.provideLexer(e) : e ? x.lex : x.lexInline)(n, i); + i.hooks && (a = i.hooks.processAllTokens(a)), i.walkTokens && this.walkTokens(a, i.walkTokens); + let p = (i.hooks ? i.hooks.provideParser(e) : e ? b.parse : b.parseInline)(a, i); + return i.hooks && (p = i.hooks.postprocess(p)), p; + } catch (u) { + return o(u); + } + }; + } + onError(e, t) { + return (n) => { + if (n.message += ` +Please report this to https://github.com/markedjs/marked.`, e) { + let s = "

    An error occurred:

    " + O(n.message + "", !0) + "
    "; + return t ? Promise.resolve(s) : s; + } + if (t) return Promise.reject(n); + throw n; + }; + } +}; +var z = new q(); +function g(l, e) { + return z.parse(l, e); +} +g.options = g.setOptions = function(l) { + return z.setOptions(l), g.defaults = z.defaults, N(g.defaults), g; +}; +g.getDefaults = M; +g.defaults = T; +g.use = function(...l) { + return z.use(...l), g.defaults = z.defaults, N(g.defaults), g; +}; +g.walkTokens = function(l, e) { + return z.walkTokens(l, e); +}; +g.parseInline = z.parseInline; +g.Parser = b; +g.parser = b.parse; +g.Renderer = y; +g.TextRenderer = L; +g.Lexer = x; +g.lexer = x.lex; +g.Tokenizer = w; +g.Hooks = P; +g.parse = g; +var Ft = g.options; +var Ut = g.setOptions; +var Kt = g.use; +var Wt = g.walkTokens; +var Xt = g.parseInline; +var Jt = g; +var Vt = b.parse; +var Yt = x.lex; +//#endregion +export { P as Hooks, x as Lexer, q as Marked, b as Parser, y as Renderer, L as TextRenderer, w as Tokenizer, T as defaults, M as getDefaults, Yt as lexer, g as marked, Ft as options, Jt as parse, Xt as parseInline, Vt as parser, Ut as setOptions, Kt as use, Wt as walkTokens }; diff --git a/frontend/node_modules/.vite/deps/marked.js.map b/frontend/node_modules/.vite/deps/marked.js.map new file mode 100644 index 0000000..947f148 --- /dev/null +++ b/frontend/node_modules/.vite/deps/marked.js.map @@ -0,0 +1 @@ +{"version":3,"file":"marked.js","names":[],"sources":["../../marked/lib/marked.esm.js"],"sourcesContent":["/**\n * marked v18.0.5 - a markdown parser\n * Copyright (c) 2018-2026, MarkedJS. (MIT License)\n * Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License)\n * https://github.com/markedjs/marked\n */\n\n/**\n * DO NOT EDIT THIS FILE\n * The code in this file is generated from files in ./src/\n */\n\nfunction M(){return{async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null}}var T=M();function N(l){T=l}var _={exec:()=>null};function E(l){let e=[];return t=>{let n=Math.max(0,Math.min(3,t-1)),s=e[n];return s||(s=l(n),e[n]=s),s}}function d(l,e=\"\"){let t=typeof l==\"string\"?l:l.source,n={replace:(s,r)=>{let i=typeof r==\"string\"?r:r.source;return i=i.replace(m.caret,\"$1\"),t=t.replace(s,i),n},getRegex:()=>new RegExp(t,e)};return n}var Te=((l=\"\")=>{try{return!!new RegExp(\"(?<=1)(?/,blockquoteSetextReplace:/\\n {0,3}((?:=+|-+) *)(?=\\n|$)/g,blockquoteSetextReplace2:/^ {0,3}>[ \\t]?/gm,listReplaceNesting:/^ {1,4}(?=( {4})*[^ ])/g,listIsTask:/^\\[[ xX]\\] +\\S/,listReplaceTask:/^\\[[ xX]\\] +/,listTaskCheckbox:/\\[[ 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,caret:/(^|[^\\[])\\^/g,percentDecode:/%25/g,findPipe:/\\|/g,splitPipe:/ \\|/,slashPipe:/\\\\\\|/g,carriageReturn:/\\r\\n|\\r/g,spaceLine:/^ +$/gm,notSpaceStart:/^\\S*/,endingNewline:/\\n$/,listItemRegex:l=>new RegExp(`^( {0,3}${l})((?:[\t ][^\\\\n]*)?(?:\\\\n|$))`),nextBulletRegex:E(l=>new RegExp(`^ {0,${l}}(?:[*+-]|\\\\d{1,9}[.)])((?:[ \t][^\\\\n]*)?(?:\\\\n|$))`)),hrRegex:E(l=>new RegExp(`^ {0,${l}}((?:- *){3,}|(?:_ *){3,}|(?:\\\\* *){3,})(?:\\\\n+|$)`)),fencesBeginRegex:E(l=>new RegExp(`^ {0,${l}}(?:\\`\\`\\`|~~~)`)),headingBeginRegex:E(l=>new RegExp(`^ {0,${l}}#`)),htmlBeginRegex:E(l=>new RegExp(`^ {0,${l}}<(?:[a-z].*>|!--)`,\"i\")),blockquoteBeginRegex:E(l=>new RegExp(`^ {0,${l}}>`))},Oe=/^(?:[ \\t]*(?:\\n|$))+/,we=/^((?: {4}| {0,3}\\t)[^\\n]+(?:\\n(?:[ \\t]*(?:\\n|$))*)?)+/,ye=/^ {0,3}(`{3,}(?=[^`\\n]*(?:\\n|$))|~{3,})([^\\n]*)(?:\\n|$)(?:|([\\s\\S]*?)(?:\\n|$))(?: {0,3}\\1[~`]* *(?=\\n|$)|$)/,B=/^ {0,3}((?:-[\\t ]*){3,}|(?:_[ \\t]*){3,}|(?:\\*[ \\t]*){3,})(?:\\n+|$)/,Pe=/^ {0,3}(#{1,6})(?=\\s|$)(.*)(?:\\n+|$)/,j=/ {0,3}(?:[*+-]|\\d{1,9}[.)])/,oe=/^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\\n(?!\\s*?\\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/,ae=d(oe).replace(/bull/g,j).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(),Se=d(oe).replace(/bull/g,j).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(),F=/^([^\\n]+(?:\\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\\n)[^\\n]+)*)/,$e=/^[^\\n]+/,U=/(?!\\s*\\])(?:\\\\[\\s\\S]|[^\\[\\]\\\\])+/,Le=d(/^ {0,3}\\[(label)\\]: *(?:\\n[ \\t]*)?([^<\\s][^\\s]*|<.*?>)(?:(?: +(?:\\n[ \\t]*)?| *\\n[ \\t]*)(title))? *(?:\\n+|$)/).replace(\"label\",U).replace(\"title\",/(?:\"(?:\\\\\"?|[^\"\\\\])*\"|'[^'\\n]*(?:\\n[^'\\n]+)*\\n?'|\\([^()]*\\))/).getRegex(),_e=d(/^(bull)([ \\t][^\\n]*?)?(?:\\n|$)/).replace(/bull/g,j).getRegex(),H=\"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\",K=/|$))/,ze=d(\"^ {0,3}(?:<(script|pre|style|textarea)[\\\\s>][\\\\s\\\\S]*?(?:[^\\\\n]*\\\\n+|$)|comment[^\\\\n]*(\\\\n+|$)|<\\\\?[\\\\s\\\\S]*?(?:\\\\?>\\\\n*|$)|\\\\n*|$)|\\\\n*|$)|)[\\\\s\\\\S]*?(?:(?:\\\\n[ \t]*)+\\\\n|$)|<(?!script|pre|style|textarea)([a-z][\\\\w-]*)(?:attribute)*? */?>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \t]*)+\\\\n|$)|(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \t]*)+\\\\n|$))\",\"i\").replace(\"comment\",K).replace(\"tag\",H).replace(\"attribute\",/ +[a-zA-Z:_][\\w.:-]*(?: *= *\"[^\"\\n]*\"| *= *'[^'\\n]*'| *= *[^\\s\"'=<>`]+)?/).getRegex(),le=d(F).replace(\"hr\",B).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[.)])[ \\\\t]+[^ \\\\t\\\\n]\").replace(\"html\",\")|<(?:script|pre|style|textarea|!--)\").replace(\"tag\",H).getRegex(),Me=d(/^( {0,3}> ?(paragraph|[^\\n]*)(?:\\n|$))+/).replace(\"paragraph\",le).getRegex(),W={blockquote:Me,code:we,def:Le,fences:ye,heading:Pe,hr:B,html:ze,lheading:ae,list:_e,newline:Oe,paragraph:le,table:_,text:$e},se=d(\"^ *([^\\\\n ].*)\\\\n {0,3}((?:\\\\| *)?:?-+:? *(?:\\\\| *:?-+:? *)*(?:\\\\| *)?)(?:\\\\n((?:(?! *\\\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\\\n|$))*)\\\\n*|$)\").replace(\"hr\",B).replace(\"heading\",\" {0,3}#{1,6}(?:\\\\s|$)\").replace(\"blockquote\",\" {0,3}>\").replace(\"code\",\"(?: {4}| {0,3}\t)[^\\\\n]\").replace(\"fences\",\" {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n\").replace(\"list\",\" {0,3}(?:[*+-]|1[.)])[ \\\\t]\").replace(\"html\",\")|<(?:script|pre|style|textarea|!--)\").replace(\"tag\",H).getRegex(),Ee={...W,lheading:Se,table:se,paragraph:d(F).replace(\"hr\",B).replace(\"heading\",\" {0,3}#{1,6}(?:\\\\s|$)\").replace(\"|lheading\",\"\").replace(\"table\",se).replace(\"blockquote\",\" {0,3}>\").replace(\"fences\",\" {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n\").replace(\"list\",\" {0,3}(?:[*+-]|1[.)])[ \\\\t]+[^ \\\\t\\\\n]\").replace(\"html\",\")|<(?:script|pre|style|textarea|!--)\").replace(\"tag\",H).getRegex()},Ie={...W,html:d(`^ *(?:comment *(?:\\\\n|\\\\s*$)|<(tag)[\\\\s\\\\S]+? *(?:\\\\n{2,}|\\\\s*$)|\\\\s]*)*?/?> *(?:\\\\n{2,}|\\\\s*$))`).replace(\"comment\",K).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:_,lheading:/^(.+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/,paragraph:d(F).replace(\"hr\",B).replace(\"heading\",` *#{1,6} *[^\n]`).replace(\"lheading\",ae).replace(\"|table\",\"\").replace(\"blockquote\",\" {0,3}>\").replace(\"|fences\",\"\").replace(\"|list\",\"\").replace(\"|html\",\"\").replace(\"|tag\",\"\").getRegex()},Ae=/^\\\\([!\"#$%&'()*+,\\-./:;<=>?@\\[\\]\\\\^_`{|}~])/,Ce=/^(`+)([^`]|[^`][\\s\\S]*?[^`])\\1(?!`)/,ue=/^( {2,}|\\\\)\\n(?!\\s*$)/,Be=/^(`+|[^`])(?:(?= {2,}\\n)|[\\s\\S]*?(?:(?=[\\\\`+)[^`]+\\k(?!`))*?\\]\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)]|\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)])*\\))*\\)/).replace(\"precode-\",Te?\"(?`+)[^`]+\\k(?!`)/).replace(\"html\",/<(?! )[^<>]*?>/).getRegex(),ce=/^(?:\\*+(?:((?!\\*)punct)|([^\\s*]))?)|^_+(?:((?!_)punct)|([^\\s_]))?/,Ze=d(ce,\"u\").replace(/punct/g,I).getRegex(),Ge=d(ce,\"u\").replace(/punct/g,pe).getRegex(),he=\"^[^_*]*?__[^_*]*?\\\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\\\*)punct(\\\\*+)(?=[\\\\s]|$)|notPunctSpace(\\\\*+)(?!\\\\*)(?=punctSpace|$)|(?!\\\\*)punctSpace(\\\\*+)(?=notPunctSpace)|[\\\\s](\\\\*+)(?!\\\\*)(?=punct)|(?!\\\\*)punct(\\\\*+)(?!\\\\*)(?=punct)|notPunctSpace(\\\\*+)(?=notPunctSpace)\",Ne=d(he,\"gu\").replace(/notPunctSpace/g,X).replace(/punctSpace/g,Z).replace(/punct/g,I).getRegex(),Qe=d(he,\"gu\").replace(/notPunctSpace/g,ve).replace(/punctSpace/g,qe).replace(/punct/g,pe).getRegex(),je=d(\"^[^_*]*?\\\\*\\\\*[^_*]*?_[^_*]*?(?=\\\\*\\\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)\",\"gu\").replace(/notPunctSpace/g,X).replace(/punctSpace/g,Z).replace(/punct/g,I).getRegex(),Fe=d(/^~~?(?:((?!~)punct)|[^\\s~])/,\"u\").replace(/punct/g,I).getRegex(),Ue=\"^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)\",Ke=d(Ue,\"gu\").replace(/notPunctSpace/g,X).replace(/punctSpace/g,Z).replace(/punct/g,I).getRegex(),We=d(/\\\\(punct)/,\"gu\").replace(/punct/g,I).getRegex(),Xe=d(/^<(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(),Je=d(K).replace(\"(?:-->|$)\",\"-->\").getRegex(),Ve=d(\"^comment|^|^<[a-zA-Z][\\\\w-]*(?:attribute)*?\\\\s*/?>|^<\\\\?[\\\\s\\\\S]*?\\\\?>|^|^\").replace(\"comment\",Je).replace(\"attribute\",/\\s+[a-zA-Z:_][\\w.:-]*(?:\\s*=\\s*\"[^\"]*\"|\\s*=\\s*'[^']*'|\\s*=\\s*[^\\s\"'=<>`]+)?/).getRegex(),v=/(?:\\[(?:\\\\[\\s\\S]|[^\\[\\]\\\\])*\\]|\\\\[\\s\\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\\])|[^\\[\\]\\\\`])*?/,Ye=d(/^!?\\[(label)\\]\\(\\s*(href)(?:(?:[ \\t]+(?:\\n[ \\t]*)?|\\n[ \\t]*)(title))?\\s*\\)/).replace(\"label\",v).replace(\"href\",/<(?:\\\\.|[^\\n<>\\\\])+>|[^ \\t\\n\\x00-\\x1f]*/).replace(\"title\",/\"(?:\\\\\"?|[^\"\\\\])*\"|'(?:\\\\'?|[^'\\\\])*'|\\((?:\\\\\\)?|[^)\\\\])*\\)/).getRegex(),ke=d(/^!?\\[(label)\\]\\[(ref)\\]/).replace(\"label\",v).replace(\"ref\",U).getRegex(),de=d(/^!?\\[(ref)\\](?:\\[\\])?/).replace(\"ref\",U).getRegex(),et=d(\"reflink|nolink(?!\\\\()\",\"g\").replace(\"reflink\",ke).replace(\"nolink\",de).getRegex(),ie=/[hH][tT][tT][pP][sS]?|[fF][tT][pP]/,J={_backpedal:_,anyPunctuation:We,autolink:Xe,blockSkip:He,br:ue,code:Ce,del:_,delLDelim:_,delRDelim:_,emStrongLDelim:Ze,emStrongRDelimAst:Ne,emStrongRDelimUnd:je,escape:Ae,link:Ye,nolink:de,punctuation:De,reflink:ke,reflinkSearch:et,tag:Ve,text:Be,url:_},tt={...J,link:d(/^!?\\[(label)\\]\\((.*?)\\)/).replace(\"label\",v).getRegex(),reflink:d(/^!?\\[(label)\\]\\s*\\[([^\\]]*)\\]/).replace(\"label\",v).getRegex()},Q={...J,emStrongRDelimAst:Qe,emStrongLDelim:Ge,delLDelim:Fe,delRDelim:Ke,url:d(/^((?:protocol):\\/\\/|www\\.)(?:[a-zA-Z0-9\\-]+\\.?)+[^\\s<]*|^email/).replace(\"protocol\",ie).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\\S]|[^\\\\])*?(?:\\\\[\\s\\S]|[^\\s~\\\\]))\\1(?=[^~]|$)/,text:d(/^([`~]+|[^`~])(?:(?= {2,}\\n)|(?=[a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-]+@)|[\\s\\S]*?(?:(?=[\\\\\":\">\",'\"':\""\",\"'\":\"'\"},ge=l=>rt[l];function O(l,e){if(e){if(m.escapeTest.test(l))return l.replace(m.escapeReplace,ge)}else if(m.escapeTestNoEncode.test(l))return l.replace(m.escapeReplaceNoEncode,ge);return l}function V(l){try{l=encodeURI(l).replace(m.percentDecode,\"%\")}catch{return null}return l}function Y(l,e){let t=l.replace(m.findPipe,(r,i,o)=>{let u=!1,a=i;for(;--a>=0&&o[a]===\"\\\\\";)u=!u;return u?\"|\":\" |\"}),n=t.split(m.splitPipe),s=0;if(n[0].trim()||n.shift(),n.length>0&&!n.at(-1)?.trim()&&n.pop(),e)if(n.length>e)n.splice(e);else for(;n.length=0&&m.blankLine.test(e[t]);)t--;return e.length-t<=2?l:e.slice(0,t+1).join(`\n`)}function fe(l,e){if(l.indexOf(e[1])===-1)return-1;let t=0;for(let n=0;n0?-2:-1}function me(l,e=0){let t=e,n=\"\";for(let s of l)if(s===\"\t\"){let r=4-t%4;n+=\" \".repeat(r),t+=r}else n+=s,t++;return n}function xe(l,e,t,n,s){let r=e.href,i=e.title||null,o=l[1].replace(s.other.outputLinkReplace,\"$1\");n.state.inLink=!0;let u={type:l[0].charAt(0)===\"!\"?\"image\":\"link\",raw:t,href:r,title:i,text:o,tokens:n.inlineTokens(o)};return n.state.inLink=!1,u}function st(l,e,t){let n=l.match(t.other.indentCodeCompensation);if(n===null)return e;let s=n[1];return e.split(`\n`).map(r=>{let i=r.match(t.other.beginningSpace);if(i===null)return r;let[o]=i;return o.length>=s.length?r.slice(s.length):r}).join(`\n`)}var w=class{options;rules;lexer;constructor(e){this.options=e||T}space(e){let t=this.rules.block.newline.exec(e);if(t&&t[0].length>0)return{type:\"space\",raw:t[0]}}code(e){let t=this.rules.block.code.exec(e);if(t){let n=this.options.pedantic?t[0]:ee(t[0]),s=n.replace(this.rules.other.codeRemoveIndent,\"\");return{type:\"code\",raw:n,codeBlockStyle:\"indented\",text:s}}}fences(e){let t=this.rules.block.fences.exec(e);if(t){let n=t[0],s=st(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:s}}}heading(e){let t=this.rules.block.heading.exec(e);if(t){let n=t[2].trim();if(this.rules.other.endingHash.test(n)){let s=$(n,\"#\");(this.options.pedantic||!s||this.rules.other.endingSpaceChar.test(s))&&(n=s.trim())}return{type:\"heading\",raw:$(t[0],`\n`),depth:t[1].length,text:n,tokens:this.lexer.inline(n)}}}hr(e){let t=this.rules.block.hr.exec(e);if(t)return{type:\"hr\",raw:$(t[0],`\n`)}}blockquote(e){let t=this.rules.block.blockquote.exec(e);if(t){let n=$(t[0],`\n`).split(`\n`),s=\"\",r=\"\",i=[];for(;n.length>0;){let o=!1,u=[],a;for(a=0;a1,r={type:\"list\",raw:\"\",ordered:s,start:s?+n.slice(0,-1):\"\",loose:!1,items:[]};n=s?`\\\\d{1,9}\\\\${n.slice(-1)}`:`\\\\${n}`,this.options.pedantic&&(n=s?n:\"[*+-]\");let i=this.rules.other.listItemRegex(n),o=!1;for(;e;){let a=!1,c=\"\",p=\"\";if(!(t=i.exec(e))||this.rules.block.hr.test(e))break;c=t[0],e=e.substring(c.length);let k=me(t[2].split(`\n`,1)[0],t[1].length),h=e.split(`\n`,1)[0],R=!k.trim(),f=0;if(this.options.pedantic?(f=2,p=k.trimStart()):R?f=t[1].length+1:(f=k.search(this.rules.other.nonSpaceChar),f=f>4?1:f,p=k.slice(f),f+=t[1].length),R&&this.rules.other.blankLine.test(h)&&(c+=h+`\n`,e=e.substring(h.length+1),a=!0),!a){let S=this.rules.other.nextBulletRegex(f),te=this.rules.other.hrRegex(f),ne=this.rules.other.fencesBeginRegex(f),re=this.rules.other.headingBeginRegex(f),be=this.rules.other.htmlBeginRegex(f),Re=this.rules.other.blockquoteBeginRegex(f);for(;e;){let G=e.split(`\n`,1)[0],C;if(h=G,this.options.pedantic?(h=h.replace(this.rules.other.listReplaceNesting,\" \"),C=h):C=h.replace(this.rules.other.tabCharGlobal,\" \"),ne.test(h)||re.test(h)||be.test(h)||Re.test(h)||S.test(h)||te.test(h))break;if(C.search(this.rules.other.nonSpaceChar)>=f||!h.trim())p+=`\n`+C.slice(f);else{if(R||k.replace(this.rules.other.tabCharGlobal,\" \").search(this.rules.other.nonSpaceChar)>=4||ne.test(k)||re.test(k)||te.test(k))break;p+=`\n`+h}R=!h.trim(),c+=G+`\n`,e=e.substring(G.length+1),k=C.slice(f)}}r.loose||(o?r.loose=!0:this.rules.other.doubleBlankLine.test(c)&&(o=!0)),r.items.push({type:\"list_item\",raw:c,task:!!this.options.gfm&&this.rules.other.listIsTask.test(p),loose:!1,text:p,tokens:[]}),r.raw+=c}let u=r.items.at(-1);if(u)u.raw=u.raw.trimEnd(),u.text=u.text.trimEnd();else return;r.raw=r.raw.trimEnd();for(let a of r.items){this.lexer.state.top=!1,a.tokens=this.lexer.blockTokens(a.text,[]);let c=a.tokens[0];if(a.task&&(c?.type===\"text\"||c?.type===\"paragraph\")){a.text=a.text.replace(this.rules.other.listReplaceTask,\"\"),c.raw=c.raw.replace(this.rules.other.listReplaceTask,\"\"),c.text=c.text.replace(this.rules.other.listReplaceTask,\"\");for(let k=this.lexer.inlineQueue.length-1;k>=0;k--)if(this.rules.other.listIsTask.test(this.lexer.inlineQueue[k].src)){this.lexer.inlineQueue[k].src=this.lexer.inlineQueue[k].src.replace(this.rules.other.listReplaceTask,\"\");break}let p=this.rules.other.listTaskCheckbox.exec(a.raw);if(p){let k={type:\"checkbox\",raw:p[0]+\" \",checked:p[0]!==\"[ ]\"};a.checked=k.checked,r.loose?a.tokens[0]&&[\"paragraph\",\"text\"].includes(a.tokens[0].type)&&\"tokens\"in a.tokens[0]&&a.tokens[0].tokens?(a.tokens[0].raw=k.raw+a.tokens[0].raw,a.tokens[0].text=k.raw+a.tokens[0].text,a.tokens[0].tokens.unshift(k)):a.tokens.unshift({type:\"paragraph\",raw:k.raw,text:k.raw,tokens:[k]}):a.tokens.unshift(k)}}else a.task&&(a.task=!1);if(!r.loose){let p=a.tokens.filter(h=>h.type===\"space\"),k=p.length>0&&p.some(h=>this.rules.other.anyLine.test(h.raw));r.loose=k}}if(r.loose)for(let a of r.items){a.loose=!0;for(let c of a.tokens)c.type===\"text\"&&(c.type=\"paragraph\")}return r}}html(e){let t=this.rules.block.html.exec(e);if(t){let n=ee(t[0]);return{type:\"html\",block:!0,raw:n,pre:t[1]===\"pre\"||t[1]===\"script\"||t[1]===\"style\",text:n}}}def(e){let t=this.rules.block.def.exec(e);if(t){let n=t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal,\" \"),s=t[2]?t[2].replace(this.rules.other.hrefBrackets,\"$1\").replace(this.rules.inline.anyPunctuation,\"$1\"):\"\",r=t[3]?t[3].substring(1,t[3].length-1).replace(this.rules.inline.anyPunctuation,\"$1\"):t[3];return{type:\"def\",tag:n,raw:$(t[0],`\n`),href:s,title:r}}}table(e){let t=this.rules.block.table.exec(e);if(!t||!this.rules.other.tableDelimiter.test(t[2]))return;let n=Y(t[1]),s=t[2].replace(this.rules.other.tableAlignChars,\"\").split(\"|\"),r=t[3]?.trim()?t[3].replace(this.rules.other.tableRowBlankLine,\"\").split(`\n`):[],i={type:\"table\",raw:$(t[0],`\n`),header:[],align:[],rows:[]};if(n.length===s.length){for(let o of s)this.rules.other.tableAlignRight.test(o)?i.align.push(\"right\"):this.rules.other.tableAlignCenter.test(o)?i.align.push(\"center\"):this.rules.other.tableAlignLeft.test(o)?i.align.push(\"left\"):i.align.push(null);for(let o=0;o({text:u,tokens:this.lexer.inline(u),header:!1,align:i.align[a]})));return i}}lheading(e){let t=this.rules.block.lheading.exec(e);if(t){let n=t[1].trim();return{type:\"heading\",raw:$(t[0],`\n`),depth:t[2].charAt(0)===\"=\"?1:2,text:n,tokens:this.lexer.inline(n)}}}paragraph(e){let t=this.rules.block.paragraph.exec(e);if(t){let n=t[1].charAt(t[1].length-1)===`\n`?t[1].slice(0,-1):t[1];return{type:\"paragraph\",raw:t[0],text:n,tokens:this.lexer.inline(n)}}}text(e){let 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){let t=this.rules.inline.escape.exec(e);if(t)return{type:\"escape\",raw:t[0],text:t[1]}}tag(e){let 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){let t=this.rules.inline.link.exec(e);if(t){let n=t[2].trim();if(!this.options.pedantic&&this.rules.other.startAngleBracket.test(n)){if(!this.rules.other.endAngleBracket.test(n))return;let i=$(n.slice(0,-1),\"\\\\\");if((n.length-i.length)%2===0)return}else{let i=fe(t[2],\"()\");if(i===-2)return;if(i>-1){let u=(t[0].indexOf(\"!\")===0?5:4)+t[1].length+i;t[2]=t[2].substring(0,i),t[0]=t[0].substring(0,u).trim(),t[3]=\"\"}}let s=t[2],r=\"\";if(this.options.pedantic){let i=this.rules.other.pedanticHrefTitle.exec(s);i&&(s=i[1],r=i[3])}else r=t[3]?t[3].slice(1,-1):\"\";return s=s.trim(),this.rules.other.startAngleBracket.test(s)&&(this.options.pedantic&&!this.rules.other.endAngleBracket.test(n)?s=s.slice(1):s=s.slice(1,-1)),xe(t,{href:s&&s.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))){let s=(n[2]||n[1]).replace(this.rules.other.multipleSpaceGlobal,\" \"),r=t[s.toLowerCase()];if(!r){let i=n[0].charAt(0);return{type:\"text\",raw:i,text:i}}return xe(n,r,n[0],this.lexer,this.rules)}}emStrong(e,t,n=\"\"){let s=this.rules.inline.emStrongLDelim.exec(e);if(!s||!s[1]&&!s[2]&&!s[3]&&!s[4]||s[4]&&n.match(this.rules.other.unicodeAlphaNumeric))return;if(!(s[1]||s[3]||\"\")||!n||this.rules.inline.punctuation.exec(n)){let i=[...s[0]].length-1,o,u,a=i,c=0,p=s[0][0]===\"*\"?this.rules.inline.emStrongRDelimAst:this.rules.inline.emStrongRDelimUnd;for(p.lastIndex=0,t=t.slice(-1*e.length+i);(s=p.exec(t))!==null;){if(o=s[1]||s[2]||s[3]||s[4]||s[5]||s[6],!o)continue;if(u=[...o].length,s[3]||s[4]){a+=u;continue}else if((s[5]||s[6])&&i%3&&!((i+u)%3)){c+=u;continue}if(a-=u,a>0)continue;u=Math.min(u,u+a+c);let k=[...s[0]][0].length,h=e.slice(0,i+s.index+k+u);if(Math.min(i,u)%2){let f=h.slice(1,-1);return{type:\"em\",raw:h,text:f,tokens:this.lexer.inlineTokens(f)}}let R=h.slice(2,-2);return{type:\"strong\",raw:h,text:R,tokens:this.lexer.inlineTokens(R)}}}}codespan(e){let t=this.rules.inline.code.exec(e);if(t){let n=t[2].replace(this.rules.other.newLineCharGlobal,\" \"),s=this.rules.other.nonSpaceChar.test(n),r=this.rules.other.startingSpaceChar.test(n)&&this.rules.other.endingSpaceChar.test(n);return s&&r&&(n=n.substring(1,n.length-1)),{type:\"codespan\",raw:t[0],text:n}}}br(e){let t=this.rules.inline.br.exec(e);if(t)return{type:\"br\",raw:t[0]}}del(e,t,n=\"\"){let s=this.rules.inline.delLDelim.exec(e);if(!s)return;if(!(s[1]||\"\")||!n||this.rules.inline.punctuation.exec(n)){let i=[...s[0]].length-1,o,u,a=i,c=this.rules.inline.delRDelim;for(c.lastIndex=0,t=t.slice(-1*e.length+i);(s=c.exec(t))!==null;){if(o=s[1]||s[2]||s[3]||s[4]||s[5]||s[6],!o||(u=[...o].length,u!==i))continue;if(s[3]||s[4]){a+=u;continue}if(a-=u,a>0)continue;u=Math.min(u,u+a);let p=[...s[0]][0].length,k=e.slice(0,i+s.index+p+u),h=k.slice(i,-i);return{type:\"del\",raw:k,text:h,tokens:this.lexer.inlineTokens(h)}}}}autolink(e){let t=this.rules.inline.autolink.exec(e);if(t){let n,s;return t[2]===\"@\"?(n=t[1],s=\"mailto:\"+n):(n=t[1],s=n),{type:\"link\",raw:t[0],text:n,href:s,tokens:[{type:\"text\",raw:n,text:n}]}}}url(e){let t;if(t=this.rules.inline.url.exec(e)){let n,s;if(t[2]===\"@\")n=t[0],s=\"mailto:\"+n;else{let r;do r=t[0],t[0]=this.rules.inline._backpedal.exec(t[0])?.[0]??\"\";while(r!==t[0]);n=t[0],t[1]===\"www.\"?s=\"http://\"+t[0]:s=t[0]}return{type:\"link\",raw:t[0],text:n,href:s,tokens:[{type:\"text\",raw:n,text:n}]}}}inlineText(e){let t=this.rules.inline.text.exec(e);if(t){let n=this.lexer.state.inRawBlock;return{type:\"text\",raw:t[0],text:t[0],escaped:n}}}};var x=class l{tokens;options;state;inlineQueue;tokenizer;constructor(e){this.tokens=[],this.tokens.links=Object.create(null),this.options=e||T,this.options.tokenizer=this.options.tokenizer||new w,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options,this.tokenizer.lexer=this,this.inlineQueue=[],this.state={inLink:!1,inRawBlock:!1,top:!0};let t={other:m,block:D.normal,inline:A.normal};this.options.pedantic?(t.block=D.pedantic,t.inline=A.pedantic):this.options.gfm&&(t.block=D.gfm,this.options.breaks?t.inline=A.breaks:t.inline=A.gfm),this.tokenizer.rules=t}static get rules(){return{block:D,inline:A}}static lex(e,t){return new l(t).lex(e)}static lexInline(e,t){return new l(t).inlineTokens(e)}lex(e){e=e.replace(m.carriageReturn,`\n`),this.blockTokens(e,this.tokens);for(let t=0;t(r=o.call({lexer:this},e,t))?(e=e.substring(r.raw.length),t.push(r),!0):!1))continue;if(r=this.tokenizer.space(e)){e=e.substring(r.raw.length);let o=t.at(-1);r.raw.length===1&&o!==void 0?o.raw+=`\n`:t.push(r);continue}if(r=this.tokenizer.code(e)){e=e.substring(r.raw.length);let o=t.at(-1);o?.type===\"paragraph\"||o?.type===\"text\"?(o.raw+=(o.raw.endsWith(`\n`)?\"\":`\n`)+r.raw,o.text+=`\n`+r.text,this.inlineQueue.at(-1).src=o.text):t.push(r);continue}if(r=this.tokenizer.fences(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.heading(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.hr(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.blockquote(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.list(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.html(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.def(e)){e=e.substring(r.raw.length);let o=t.at(-1);o?.type===\"paragraph\"||o?.type===\"text\"?(o.raw+=(o.raw.endsWith(`\n`)?\"\":`\n`)+r.raw,o.text+=`\n`+r.raw,this.inlineQueue.at(-1).src=o.text):this.tokens.links[r.tag]||(this.tokens.links[r.tag]={href:r.href,title:r.title},t.push(r));continue}if(r=this.tokenizer.table(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.lheading(e)){e=e.substring(r.raw.length),t.push(r);continue}let i=e;if(this.options.extensions?.startBlock){let o=1/0,u=e.slice(1),a;this.options.extensions.startBlock.forEach(c=>{a=c.call({lexer:this},u),typeof a==\"number\"&&a>=0&&(o=Math.min(o,a))}),o<1/0&&o>=0&&(i=e.substring(0,o+1))}if(this.state.top&&(r=this.tokenizer.paragraph(i))){let o=t.at(-1);n&&o?.type===\"paragraph\"?(o.raw+=(o.raw.endsWith(`\n`)?\"\":`\n`)+r.raw,o.text+=`\n`+r.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=o.text):t.push(r),n=i.length!==e.length,e=e.substring(r.raw.length);continue}if(r=this.tokenizer.text(e)){e=e.substring(r.raw.length);let o=t.at(-1);o?.type===\"text\"?(o.raw+=(o.raw.endsWith(`\n`)?\"\":`\n`)+r.raw,o.text+=`\n`+r.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=o.text):t.push(r);continue}if(e){this.infiniteLoopError(e.charCodeAt(0));break}}return this.state.top=!0,t}inline(e,t=[]){return this.inlineQueue.push({src:e,tokens:t}),t}inlineTokens(e,t=[]){this.tokenizer.lexer=this;let n=e,s=null;if(this.tokens.links){let a=Object.keys(this.tokens.links);if(a.length>0)for(;(s=this.tokenizer.rules.inline.reflinkSearch.exec(n))!==null;)a.includes(s[0].slice(s[0].lastIndexOf(\"[\")+1,-1))&&(n=n.slice(0,s.index)+\"[\"+\"a\".repeat(s[0].length-2)+\"]\"+n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;(s=this.tokenizer.rules.inline.anyPunctuation.exec(n))!==null;)n=n.slice(0,s.index)+\"++\"+n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);let r;for(;(s=this.tokenizer.rules.inline.blockSkip.exec(n))!==null;)r=s[2]?s[2].length:0,n=n.slice(0,s.index+r)+\"[\"+\"a\".repeat(s[0].length-r-2)+\"]\"+n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);n=this.options.hooks?.emStrongMask?.call({lexer:this},n)??n;let i=!1,o=\"\",u=1/0;for(;e;){if(e.length(a=p.call({lexer:this},e,t))?(e=e.substring(a.raw.length),t.push(a),!0):!1))continue;if(a=this.tokenizer.escape(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.tag(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.link(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.reflink(e,this.tokens.links)){e=e.substring(a.raw.length);let p=t.at(-1);a.type===\"text\"&&p?.type===\"text\"?(p.raw+=a.raw,p.text+=a.text):t.push(a);continue}if(a=this.tokenizer.emStrong(e,n,o)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.codespan(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.br(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.del(e,n,o)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.autolink(e)){e=e.substring(a.raw.length),t.push(a);continue}if(!this.state.inLink&&(a=this.tokenizer.url(e))){e=e.substring(a.raw.length),t.push(a);continue}let c=e;if(this.options.extensions?.startInline){let p=1/0,k=e.slice(1),h;this.options.extensions.startInline.forEach(R=>{h=R.call({lexer:this},k),typeof h==\"number\"&&h>=0&&(p=Math.min(p,h))}),p<1/0&&p>=0&&(c=e.substring(0,p+1))}if(a=this.tokenizer.inlineText(c)){e=e.substring(a.raw.length),a.raw.slice(-1)!==\"_\"&&(o=a.raw.slice(-1)),i=!0;let p=t.at(-1);p?.type===\"text\"?(p.raw+=a.raw,p.text+=a.text):t.push(a);continue}if(e){this.infiniteLoopError(e.charCodeAt(0));break}}return t}infiniteLoopError(e){let t=\"Infinite loop on byte: \"+e;if(this.options.silent)console.error(t);else throw new Error(t)}};var y=class{options;parser;constructor(e){this.options=e||T}space(e){return\"\"}code({text:e,lang:t,escaped:n}){let s=(t||\"\").match(m.notSpaceStart)?.[0],r=e.replace(m.endingNewline,\"\")+`\n`;return s?'
    '+(n?r:O(r,!0))+`
    \n`:\"
    \"+(n?r:O(r,!0))+`
    \n`}blockquote({tokens:e}){return`
    \n${this.parser.parse(e)}
    \n`}html({text:e}){return e}def(e){return\"\"}heading({tokens:e,depth:t}){return`${this.parser.parseInline(e)}\n`}hr(e){return`
    \n`}list(e){let t=e.ordered,n=e.start,s=\"\";for(let o=0;o\n`+s+\"\n`}listitem(e){return`
  • ${this.parser.parse(e.tokens)}
    • \n`}checkbox({checked:e}){return\" '}paragraph({tokens:e}){return`

    ${this.parser.parseInline(e)}

    \n`}table(e){let t=\"\",n=\"\";for(let r=0;r${s}`),`\n\n`+t+`\n`+s+`
    \n`}tablerow({text:e}){return`\n${e}\n`}tablecell(e){let t=this.parser.parseInline(e.tokens),n=e.header?\"th\":\"td\";return(e.align?`<${n} align=\"${e.align}\">`:`<${n}>`)+t+`\n`}strong({tokens:e}){return`${this.parser.parseInline(e)}`}em({tokens:e}){return`${this.parser.parseInline(e)}`}codespan({text:e}){return`${O(e,!0)}`}br(e){return\"
    \"}del({tokens:e}){return`${this.parser.parseInline(e)}`}link({href:e,title:t,tokens:n}){let s=this.parser.parseInline(n),r=V(e);if(r===null)return s;e=r;let i='    \"+s+\"\",i}image({href:e,title:t,text:n,tokens:s}){s&&(n=this.parser.parseInline(s,this.parser.textRenderer));let r=V(e);if(r===null)return O(n);e=r;let i=`\"${O(n)}\"`;return\",i}text(e){return\"tokens\"in e&&e.tokens?this.parser.parseInline(e.tokens):\"escaped\"in e&&e.escaped?e.text:O(e.text)}};var L=class{strong({text:e}){return e}em({text:e}){return e}codespan({text:e}){return e}del({text:e}){return e}html({text:e}){return e}text({text:e}){return e}link({text:e}){return\"\"+e}image({text:e}){return\"\"+e}br(){return\"\"}checkbox({raw:e}){return e}};var b=class l{options;renderer;textRenderer;constructor(e){this.options=e||T,this.options.renderer=this.options.renderer||new y,this.renderer=this.options.renderer,this.renderer.options=this.options,this.renderer.parser=this,this.textRenderer=new L}static parse(e,t){return new l(t).parse(e)}static parseInline(e,t){return new l(t).parseInline(e)}parse(e){this.renderer.parser=this;let t=\"\";for(let n=0;n{let o=r[i].flat(1/0);n=n.concat(this.walkTokens(o,t))}):r.tokens&&(n=n.concat(this.walkTokens(r.tokens,t)))}}return n}use(...e){let t=this.defaults.extensions||{renderers:{},childTokens:{}};return e.forEach(n=>{let s={...n};if(s.async=this.defaults.async||s.async||!1,n.extensions&&(n.extensions.forEach(r=>{if(!r.name)throw new Error(\"extension name required\");if(\"renderer\"in r){let i=t.renderers[r.name];i?t.renderers[r.name]=function(...o){let u=r.renderer.apply(this,o);return u===!1&&(u=i.apply(this,o)),u}: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'\");let 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)}),s.extensions=t),n.renderer){let r=this.defaults.renderer||new y(this.defaults);for(let i in n.renderer){if(!(i in r))throw new Error(`renderer '${i}' does not exist`);if([\"options\",\"parser\"].includes(i))continue;let o=i,u=n.renderer[o],a=r[o];r[o]=(...c)=>{let p=u.apply(r,c);return p===!1&&(p=a.apply(r,c)),p||\"\"}}s.renderer=r}if(n.tokenizer){let r=this.defaults.tokenizer||new w(this.defaults);for(let i in n.tokenizer){if(!(i in r))throw new Error(`tokenizer '${i}' does not exist`);if([\"options\",\"rules\",\"lexer\"].includes(i))continue;let o=i,u=n.tokenizer[o],a=r[o];r[o]=(...c)=>{let p=u.apply(r,c);return p===!1&&(p=a.apply(r,c)),p}}s.tokenizer=r}if(n.hooks){let r=this.defaults.hooks||new P;for(let i in n.hooks){if(!(i in r))throw new Error(`hook '${i}' does not exist`);if([\"options\",\"block\"].includes(i))continue;let o=i,u=n.hooks[o],a=r[o];P.passThroughHooks.has(i)?r[o]=c=>{if(this.defaults.async&&P.passThroughHooksRespectAsync.has(i))return(async()=>{let k=await u.call(r,c);return a.call(r,k)})();let p=u.call(r,c);return a.call(r,p)}:r[o]=(...c)=>{if(this.defaults.async)return(async()=>{let k=await u.apply(r,c);return k===!1&&(k=await a.apply(r,c)),k})();let p=u.apply(r,c);return p===!1&&(p=a.apply(r,c)),p}}s.hooks=r}if(n.walkTokens){let r=this.defaults.walkTokens,i=n.walkTokens;s.walkTokens=function(o){let u=[];return u.push(i.call(this,o)),r&&(u=u.concat(r.call(this,o))),u}}this.defaults={...this.defaults,...s}}),this}setOptions(e){return this.defaults={...this.defaults,...e},this}lexer(e,t){return x.lex(e,t??this.defaults)}parser(e,t){return b.parse(e,t??this.defaults)}parseMarkdown(e){return(n,s)=>{let r={...s},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\"));if(i.hooks&&(i.hooks.options=i,i.hooks.block=e),i.async)return(async()=>{let u=i.hooks?await i.hooks.preprocess(n):n,c=await(i.hooks?await i.hooks.provideLexer(e):e?x.lex:x.lexInline)(u,i),p=i.hooks?await i.hooks.processAllTokens(c):c;i.walkTokens&&await Promise.all(this.walkTokens(p,i.walkTokens));let h=await(i.hooks?await i.hooks.provideParser(e):e?b.parse:b.parseInline)(p,i);return i.hooks?await i.hooks.postprocess(h):h})().catch(o);try{i.hooks&&(n=i.hooks.preprocess(n));let a=(i.hooks?i.hooks.provideLexer(e):e?x.lex:x.lexInline)(n,i);i.hooks&&(a=i.hooks.processAllTokens(a)),i.walkTokens&&this.walkTokens(a,i.walkTokens);let p=(i.hooks?i.hooks.provideParser(e):e?b.parse:b.parseInline)(a,i);return i.hooks&&(p=i.hooks.postprocess(p)),p}catch(u){return o(u)}}}onError(e,t){return n=>{if(n.message+=`\nPlease report this to https://github.com/markedjs/marked.`,e){let s=\"

    An error occurred:

    \"+O(n.message+\"\",!0)+\"
    \";return t?Promise.resolve(s):s}if(t)return Promise.reject(n);throw n}}};var z=new q;function g(l,e){return z.parse(l,e)}g.options=g.setOptions=function(l){return z.setOptions(l),g.defaults=z.defaults,N(g.defaults),g};g.getDefaults=M;g.defaults=T;g.use=function(...l){return z.use(...l),g.defaults=z.defaults,N(g.defaults),g};g.walkTokens=function(l,e){return z.walkTokens(l,e)};g.parseInline=z.parseInline;g.Parser=b;g.parser=b.parse;g.Renderer=y;g.TextRenderer=L;g.Lexer=x;g.lexer=x.lex;g.Tokenizer=w;g.Hooks=P;g.parse=g;var Ft=g.options,Ut=g.setOptions,Kt=g.use,Wt=g.walkTokens,Xt=g.parseInline,Jt=g,Vt=b.parse,Yt=x.lex;export{P as Hooks,x as Lexer,q as Marked,b as Parser,y as Renderer,L as TextRenderer,w as Tokenizer,T as defaults,M as getDefaults,Yt as lexer,g as marked,Ft as options,Jt as parse,Xt as parseInline,Vt as parser,Ut as setOptions,Kt as use,Wt as walkTokens};\n//# sourceMappingURL=marked.esm.js.map\n"],"mappings":"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"} \ No newline at end of file diff --git a/frontend/node_modules/.vite/deps/package.json b/frontend/node_modules/.vite/deps/package.json new file mode 100644 index 0000000..3dbc1ca --- /dev/null +++ b/frontend/node_modules/.vite/deps/package.json @@ -0,0 +1,3 @@ +{ + "type": "module" +} diff --git a/frontend/node_modules/.vite/deps/vue.js b/frontend/node_modules/.vite/deps/vue.js new file mode 100644 index 0000000..aaaaeda --- /dev/null +++ b/frontend/node_modules/.vite/deps/vue.js @@ -0,0 +1,8654 @@ +//#region node_modules/@vue/shared/dist/shared.esm-bundler.js +/** +* @vue/shared v3.5.39 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ +// @__NO_SIDE_EFFECTS__ +function makeMap(str) { + const map = /* @__PURE__ */ Object.create(null); + for (const key of str.split(",")) map[key] = 1; + return (val) => val in map; +} +var EMPTY_OBJ = Object.freeze({}); +var EMPTY_ARR = Object.freeze([]); +var NOOP = () => {}; +var NO = () => false; +var isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && (key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97); +var isModelListener = (key) => key.startsWith("onUpdate:"); +var extend = Object.assign; +var remove = (arr, el) => { + const i = arr.indexOf(el); + if (i > -1) arr.splice(i, 1); +}; +var hasOwnProperty$1 = Object.prototype.hasOwnProperty; +var hasOwn = (val, key) => hasOwnProperty$1.call(val, key); +var isArray = Array.isArray; +var isMap = (val) => toTypeString(val) === "[object Map]"; +var isSet = (val) => toTypeString(val) === "[object Set]"; +var isDate = (val) => toTypeString(val) === "[object Date]"; +var isRegExp = (val) => toTypeString(val) === "[object RegExp]"; +var isFunction = (val) => typeof val === "function"; +var isString = (val) => typeof val === "string"; +var isSymbol = (val) => typeof val === "symbol"; +var isObject = (val) => val !== null && typeof val === "object"; +var isPromise = (val) => { + return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch); +}; +var objectToString = Object.prototype.toString; +var toTypeString = (value) => objectToString.call(value); +var toRawType = (value) => { + return toTypeString(value).slice(8, -1); +}; +var isPlainObject = (val) => toTypeString(val) === "[object Object]"; +var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key; +var isReservedProp = /* @__PURE__ */ makeMap(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"); +var isBuiltInDirective = /* @__PURE__ */ makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"); +var cacheStringFunction = (fn) => { + const cache = /* @__PURE__ */ Object.create(null); + return ((str) => { + return cache[str] || (cache[str] = fn(str)); + }); +}; +var camelizeRE = /-\w/g; +var camelize = cacheStringFunction((str) => { + return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase()); +}); +var hyphenateRE = /\B([A-Z])/g; +var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase()); +var capitalize = cacheStringFunction((str) => { + return str.charAt(0).toUpperCase() + str.slice(1); +}); +var toHandlerKey = cacheStringFunction((str) => { + return str ? `on${capitalize(str)}` : ``; +}); +var hasChanged = (value, oldValue) => !Object.is(value, oldValue); +var invokeArrayFns = (fns, ...arg) => { + for (let i = 0; i < fns.length; i++) fns[i](...arg); +}; +var def = (obj, key, value, writable = false) => { + Object.defineProperty(obj, key, { + configurable: true, + enumerable: false, + writable, + value + }); +}; +var looseToNumber = (val) => { + const n = parseFloat(val); + return isNaN(n) ? val : n; +}; +var toNumber = (val) => { + const n = isString(val) ? Number(val) : NaN; + return isNaN(n) ? val : n; +}; +var _globalThis; +var getGlobalThis = () => { + return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {}); +}; +var isGloballyAllowed = /* @__PURE__ */ makeMap("Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol"); +function normalizeStyle(value) { + if (isArray(value)) { + const res = {}; + for (let i = 0; i < value.length; i++) { + const item = value[i]; + const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item); + if (normalized) for (const key in normalized) res[key] = normalized[key]; + } + return res; + } else if (isString(value) || isObject(value)) return value; +} +var listDelimiterRE = /;(?![^(]*\))/g; +var propertyDelimiterRE = /:([^]+)/; +var styleCommentRE = /\/\*[^]*?\*\//g; +function parseStringStyle(cssText) { + const ret = {}; + cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => { + if (item) { + const tmp = item.split(propertyDelimiterRE); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; +} +function stringifyStyle(styles) { + if (!styles) return ""; + if (isString(styles)) return styles; + let ret = ""; + for (const key in styles) { + const value = styles[key]; + if (isString(value) || typeof value === "number") { + const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key); + ret += `${normalizedKey}:${value};`; + } + } + return ret; +} +function normalizeClass(value) { + let res = ""; + if (isString(value)) res = value; + else if (isArray(value)) for (let i = 0; i < value.length; i++) { + const normalized = normalizeClass(value[i]); + if (normalized) res += normalized + " "; + } + else if (isObject(value)) { + for (const name in value) if (value[name]) res += name + " "; + } + return res.trim(); +} +function normalizeProps(props) { + if (!props) return null; + let { class: klass, style } = props; + if (klass && !isString(klass)) props.class = normalizeClass(klass); + if (style) props.style = normalizeStyle(style); + return props; +} +var HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot"; +var SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view"; +var MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics"; +var isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS); +var isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS); +var isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS); +var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; +var isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs); +var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`); +function includeBooleanAttr(value) { + return !!value || value === ""; +} +var isKnownHtmlAttr = /* @__PURE__ */ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`); +var isKnownSvgAttr = /* @__PURE__ */ makeMap(`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`); +function isRenderableAttrValue(value) { + if (value == null) return false; + const type = typeof value; + return type === "string" || type === "number" || type === "boolean"; +} +var cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g; +function getEscapedCssVarName(key, doubleEscape) { + return key.replace(cssVarNameEscapeSymbolsRE, (s) => doubleEscape ? s === "\"" ? "\\\\\\\"" : `\\\\${s}` : `\\${s}`); +} +function looseCompareArrays(a, b) { + if (a.length !== b.length) return false; + let equal = true; + for (let i = 0; equal && i < a.length; i++) equal = looseEqual(a[i], b[i]); + return equal; +} +function looseEqual(a, b) { + if (a === b) return true; + let aValidType = isDate(a); + let bValidType = isDate(b); + if (aValidType || bValidType) return aValidType && bValidType ? a.getTime() === b.getTime() : false; + aValidType = isSymbol(a); + bValidType = isSymbol(b); + if (aValidType || bValidType) return a === b; + aValidType = isArray(a); + bValidType = isArray(b); + if (aValidType || bValidType) return aValidType && bValidType ? looseCompareArrays(a, b) : false; + aValidType = isObject(a); + bValidType = isObject(b); + if (aValidType || bValidType) { + if (!aValidType || !bValidType) return false; + if (Object.keys(a).length !== Object.keys(b).length) return false; + for (const key in a) { + const aHasKey = a.hasOwnProperty(key); + const bHasKey = b.hasOwnProperty(key); + if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) return false; + } + } + return String(a) === String(b); +} +function looseIndexOf(arr, val) { + return arr.findIndex((item) => looseEqual(item, val)); +} +var isRef$1 = (val) => { + return !!(val && val["__v_isRef"] === true); +}; +var toDisplayString = (val) => { + return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val); +}; +var replacer = (_key, val) => { + if (isRef$1(val)) return replacer(_key, val.value); + else if (isMap(val)) return { [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2], i) => { + entries[stringifySymbol(key, i) + " =>"] = val2; + return entries; + }, {}) }; + else if (isSet(val)) return { [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v)) }; + else if (isSymbol(val)) return stringifySymbol(val); + else if (isObject(val) && !isArray(val) && !isPlainObject(val)) return String(val); + return val; +}; +var stringifySymbol = (v, i = "") => { + var _a; + return isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v; +}; +function normalizeCssVarValue(value) { + if (value == null) return "initial"; + if (typeof value === "string") return value === "" ? " " : value; + if (typeof value !== "number" || !Number.isFinite(value)) console.warn("[Vue warn] Invalid value used for CSS binding. Expected a string or a finite number but received:", value); + return String(value); +} +//#endregion +//#region node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js +/** +* @vue/reactivity v3.5.39 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ +function warn$2(msg, ...args) { + console.warn(`[Vue warn] ${msg}`, ...args); +} +var activeEffectScope; +var EffectScope = class { + constructor(detached = false) { + this.detached = detached; + /** + * @internal + */ + this._active = true; + /** + * @internal track `on` calls, allow `on` call multiple times + */ + this._on = 0; + /** + * @internal + */ + this.effects = []; + /** + * @internal + */ + this.cleanups = []; + this._isPaused = false; + this._warnOnRun = true; + this.__v_skip = true; + if (!detached && activeEffectScope) if (activeEffectScope.active) { + this.parent = activeEffectScope; + this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; + } else { + this._active = false; + this._warnOnRun = false; + } + } + get active() { + return this._active; + } + pause() { + if (this._active) { + this._isPaused = true; + let i, l; + if (this.scopes) for (i = 0, l = this.scopes.length; i < l; i++) this.scopes[i].pause(); + for (i = 0, l = this.effects.length; i < l; i++) this.effects[i].pause(); + } + } + /** + * Resumes the effect scope, including all child scopes and effects. + */ + resume() { + if (this._active) { + if (this._isPaused) { + this._isPaused = false; + let i, l; + if (this.scopes) for (i = 0, l = this.scopes.length; i < l; i++) this.scopes[i].resume(); + for (i = 0, l = this.effects.length; i < l; i++) this.effects[i].resume(); + } + } + } + run(fn) { + if (this._active) { + const currentEffectScope = activeEffectScope; + try { + activeEffectScope = this; + return fn(); + } finally { + activeEffectScope = currentEffectScope; + } + } else if (this._warnOnRun) warn$2(`cannot run an inactive effect scope.`); + } + /** + * This should only be called on non-detached scopes + * @internal + */ + on() { + if (++this._on === 1) { + this.prevScope = activeEffectScope; + activeEffectScope = this; + } + } + /** + * This should only be called on non-detached scopes + * @internal + */ + off() { + if (this._on > 0 && --this._on === 0) { + if (activeEffectScope === this) activeEffectScope = this.prevScope; + else { + let current = activeEffectScope; + while (current) { + if (current.prevScope === this) { + current.prevScope = this.prevScope; + break; + } + current = current.prevScope; + } + } + this.prevScope = void 0; + } + } + stop(fromParent) { + if (this._active) { + this._active = false; + let i, l; + for (i = 0, l = this.effects.length; i < l; i++) this.effects[i].stop(); + this.effects.length = 0; + for (i = 0, l = this.cleanups.length; i < l; i++) this.cleanups[i](); + this.cleanups.length = 0; + if (this.scopes) { + for (i = 0, l = this.scopes.length; i < l; i++) this.scopes[i].stop(true); + this.scopes.length = 0; + } + if (!this.detached && this.parent && !fromParent) { + const last = this.parent.scopes.pop(); + if (last && last !== this) { + this.parent.scopes[this.index] = last; + last.index = this.index; + } + } + this.parent = void 0; + } + } +}; +function effectScope(detached) { + return new EffectScope(detached); +} +function getCurrentScope() { + return activeEffectScope; +} +function onScopeDispose(fn, failSilently = false) { + if (activeEffectScope) activeEffectScope.cleanups.push(fn); + else if (!failSilently) warn$2(`onScopeDispose() is called when there is no active effect scope to be associated with.`); +} +var activeSub; +var pausedQueueEffects = /* @__PURE__ */ new WeakSet(); +var ReactiveEffect = class { + constructor(fn) { + this.fn = fn; + /** + * @internal + */ + this.deps = void 0; + /** + * @internal + */ + this.depsTail = void 0; + /** + * @internal + */ + this.flags = 5; + /** + * @internal + */ + this.next = void 0; + /** + * @internal + */ + this.cleanup = void 0; + this.scheduler = void 0; + if (activeEffectScope) if (activeEffectScope.active) activeEffectScope.effects.push(this); + else this.flags &= -2; + } + pause() { + this.flags |= 64; + } + resume() { + if (this.flags & 64) { + this.flags &= -65; + if (pausedQueueEffects.has(this)) { + pausedQueueEffects.delete(this); + this.trigger(); + } + } + } + /** + * @internal + */ + notify() { + if (this.flags & 2 && !(this.flags & 32)) return; + if (!(this.flags & 8)) batch(this); + } + run() { + if (!(this.flags & 1)) return this.fn(); + this.flags |= 2; + cleanupEffect(this); + prepareDeps(this); + const prevEffect = activeSub; + const prevShouldTrack = shouldTrack; + activeSub = this; + shouldTrack = true; + try { + return this.fn(); + } finally { + if (activeSub !== this) warn$2("Active effect was not restored correctly - this is likely a Vue internal bug."); + cleanupDeps(this); + activeSub = prevEffect; + shouldTrack = prevShouldTrack; + this.flags &= -3; + } + } + stop() { + if (this.flags & 1) { + for (let link = this.deps; link; link = link.nextDep) removeSub(link); + this.deps = this.depsTail = void 0; + cleanupEffect(this); + this.onStop && this.onStop(); + this.flags &= -2; + } + } + trigger() { + if (this.flags & 64) pausedQueueEffects.add(this); + else if (this.scheduler) this.scheduler(); + else this.runIfDirty(); + } + /** + * @internal + */ + runIfDirty() { + if (isDirty(this)) this.run(); + } + get dirty() { + return isDirty(this); + } +}; +var batchDepth = 0; +var batchedSub; +var batchedComputed; +function batch(sub, isComputed = false) { + sub.flags |= 8; + if (isComputed) { + sub.next = batchedComputed; + batchedComputed = sub; + return; + } + sub.next = batchedSub; + batchedSub = sub; +} +function startBatch() { + batchDepth++; +} +function endBatch() { + if (--batchDepth > 0) return; + if (batchedComputed) { + let e = batchedComputed; + batchedComputed = void 0; + while (e) { + const next = e.next; + e.next = void 0; + e.flags &= -9; + e = next; + } + } + let error; + while (batchedSub) { + let e = batchedSub; + batchedSub = void 0; + while (e) { + const next = e.next; + e.next = void 0; + e.flags &= -9; + if (e.flags & 1) try { + e.trigger(); + } catch (err) { + if (!error) error = err; + } + e = next; + } + } + if (error) throw error; +} +function prepareDeps(sub) { + for (let link = sub.deps; link; link = link.nextDep) { + link.version = -1; + link.prevActiveLink = link.dep.activeLink; + link.dep.activeLink = link; + } +} +function cleanupDeps(sub) { + let head; + let tail = sub.depsTail; + let link = tail; + while (link) { + const prev = link.prevDep; + if (link.version === -1) { + if (link === tail) tail = prev; + removeSub(link); + removeDep(link); + } else head = link; + link.dep.activeLink = link.prevActiveLink; + link.prevActiveLink = void 0; + link = prev; + } + sub.deps = head; + sub.depsTail = tail; +} +function isDirty(sub) { + for (let link = sub.deps; link; link = link.nextDep) if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) return true; + if (sub._dirty) return true; + return false; +} +function refreshComputed(computed) { + if (computed.flags & 4 && !(computed.flags & 16)) return; + computed.flags &= -17; + if (computed.globalVersion === globalVersion) return; + computed.globalVersion = globalVersion; + if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) return; + computed.flags |= 2; + const dep = computed.dep; + const prevSub = activeSub; + const prevShouldTrack = shouldTrack; + activeSub = computed; + shouldTrack = true; + try { + prepareDeps(computed); + const value = computed.fn(computed._value); + if (dep.version === 0 || hasChanged(value, computed._value)) { + computed.flags |= 128; + computed._value = value; + dep.version++; + } + } catch (err) { + dep.version++; + throw err; + } finally { + activeSub = prevSub; + shouldTrack = prevShouldTrack; + cleanupDeps(computed); + computed.flags &= -3; + } +} +function removeSub(link, soft = false) { + const { dep, prevSub, nextSub } = link; + if (prevSub) { + prevSub.nextSub = nextSub; + link.prevSub = void 0; + } + if (nextSub) { + nextSub.prevSub = prevSub; + link.nextSub = void 0; + } + if (dep.subsHead === link) dep.subsHead = nextSub; + if (dep.subs === link) { + dep.subs = prevSub; + if (!prevSub && dep.computed) { + dep.computed.flags &= -5; + for (let l = dep.computed.deps; l; l = l.nextDep) removeSub(l, true); + } + } + if (!soft && !--dep.sc && dep.map) dep.map.delete(dep.key); +} +function removeDep(link) { + const { prevDep, nextDep } = link; + if (prevDep) { + prevDep.nextDep = nextDep; + link.prevDep = void 0; + } + if (nextDep) { + nextDep.prevDep = prevDep; + link.nextDep = void 0; + } +} +function effect(fn, options) { + if (fn.effect instanceof ReactiveEffect) fn = fn.effect.fn; + const e = new ReactiveEffect(fn); + if (options) extend(e, options); + try { + e.run(); + } catch (err) { + e.stop(); + throw err; + } + const runner = e.run.bind(e); + runner.effect = e; + return runner; +} +function stop(runner) { + runner.effect.stop(); +} +var shouldTrack = true; +var trackStack = []; +function pauseTracking() { + trackStack.push(shouldTrack); + shouldTrack = false; +} +function resetTracking() { + const last = trackStack.pop(); + shouldTrack = last === void 0 ? true : last; +} +function cleanupEffect(e) { + const { cleanup } = e; + e.cleanup = void 0; + if (cleanup) { + const prevSub = activeSub; + activeSub = void 0; + try { + cleanup(); + } finally { + activeSub = prevSub; + } + } +} +var globalVersion = 0; +var Link = class { + constructor(sub, dep) { + this.sub = sub; + this.dep = dep; + this.version = dep.version; + this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0; + } +}; +var Dep = class { + constructor(computed) { + this.computed = computed; + this.version = 0; + /** + * Link between this dep and the current active effect + */ + this.activeLink = void 0; + /** + * Doubly linked list representing the subscribing effects (tail) + */ + this.subs = void 0; + /** + * For object property deps cleanup + */ + this.map = void 0; + this.key = void 0; + /** + * Subscriber counter + */ + this.sc = 0; + /** + * @internal + */ + this.__v_skip = true; + this.subsHead = void 0; + } + track(debugInfo) { + if (!activeSub || !shouldTrack || activeSub === this.computed) return; + let link = this.activeLink; + if (link === void 0 || link.sub !== activeSub) { + link = this.activeLink = new Link(activeSub, this); + if (!activeSub.deps) activeSub.deps = activeSub.depsTail = link; + else { + link.prevDep = activeSub.depsTail; + activeSub.depsTail.nextDep = link; + activeSub.depsTail = link; + } + addSub(link); + } else if (link.version === -1) { + link.version = this.version; + if (link.nextDep) { + const next = link.nextDep; + next.prevDep = link.prevDep; + if (link.prevDep) link.prevDep.nextDep = next; + link.prevDep = activeSub.depsTail; + link.nextDep = void 0; + activeSub.depsTail.nextDep = link; + activeSub.depsTail = link; + if (activeSub.deps === link) activeSub.deps = next; + } + } + if (activeSub.onTrack) activeSub.onTrack(extend({ effect: activeSub }, debugInfo)); + return link; + } + trigger(debugInfo) { + this.version++; + globalVersion++; + this.notify(debugInfo); + } + notify(debugInfo) { + startBatch(); + try { + for (let head = this.subsHead; head; head = head.nextSub) if (head.sub.onTrigger && !(head.sub.flags & 8)) head.sub.onTrigger(extend({ effect: head.sub }, debugInfo)); + for (let link = this.subs; link; link = link.prevSub) if (link.sub.notify()) link.sub.dep.notify(); + } finally { + endBatch(); + } + } +}; +function addSub(link) { + link.dep.sc++; + if (link.sub.flags & 4) { + const computed = link.dep.computed; + if (computed && !link.dep.subs) { + computed.flags |= 20; + for (let l = computed.deps; l; l = l.nextDep) addSub(l); + } + const currentTail = link.dep.subs; + if (currentTail !== link) { + link.prevSub = currentTail; + if (currentTail) currentTail.nextSub = link; + } + if (link.dep.subsHead === void 0) link.dep.subsHead = link; + link.dep.subs = link; + } +} +var targetMap = /* @__PURE__ */ new WeakMap(); +var ITERATE_KEY = /* @__PURE__ */ Symbol("Object iterate"); +var MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol("Map keys iterate"); +var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("Array iterate"); +function track(target, type, key) { + if (shouldTrack && activeSub) { + let depsMap = targetMap.get(target); + if (!depsMap) targetMap.set(target, depsMap = /* @__PURE__ */ new Map()); + let dep = depsMap.get(key); + if (!dep) { + depsMap.set(key, dep = new Dep()); + dep.map = depsMap; + dep.key = key; + } + dep.track({ + target, + type, + key + }); + } +} +function trigger(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap.get(target); + if (!depsMap) { + globalVersion++; + return; + } + const run = (dep) => { + if (dep) dep.trigger({ + target, + type, + key, + newValue, + oldValue, + oldTarget + }); + }; + startBatch(); + if (type === "clear") depsMap.forEach(run); + else { + const targetIsArray = isArray(target); + const isArrayIndex = targetIsArray && isIntegerKey(key); + if (targetIsArray && key === "length") { + const newLength = Number(newValue); + depsMap.forEach((dep, key2) => { + if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) run(dep); + }); + } else { + if (key !== void 0 || depsMap.has(void 0)) run(depsMap.get(key)); + if (isArrayIndex) run(depsMap.get(ARRAY_ITERATE_KEY)); + switch (type) { + case "add": + if (!targetIsArray) { + run(depsMap.get(ITERATE_KEY)); + if (isMap(target)) run(depsMap.get(MAP_KEY_ITERATE_KEY)); + } else if (isArrayIndex) run(depsMap.get("length")); + break; + case "delete": + if (!targetIsArray) { + run(depsMap.get(ITERATE_KEY)); + if (isMap(target)) run(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + break; + case "set": + if (isMap(target)) run(depsMap.get(ITERATE_KEY)); + break; + } + } + } + endBatch(); +} +function getDepFromReactive(object, key) { + const depMap = targetMap.get(object); + return depMap && depMap.get(key); +} +function reactiveReadArray(array) { + const raw = /* @__PURE__ */ toRaw(array); + if (raw === array) return raw; + track(raw, "iterate", ARRAY_ITERATE_KEY); + return /* @__PURE__ */ isShallow(array) ? raw : raw.map(toReactive); +} +function shallowReadArray(arr) { + track(arr = /* @__PURE__ */ toRaw(arr), "iterate", ARRAY_ITERATE_KEY); + return arr; +} +function toWrapped(target, item) { + if (/* @__PURE__ */ isReadonly(target)) return /* @__PURE__ */ isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item); + return toReactive(item); +} +var arrayInstrumentations = { + __proto__: null, + [Symbol.iterator]() { + return iterator(this, Symbol.iterator, (item) => toWrapped(this, item)); + }, + concat(...args) { + return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x)); + }, + entries() { + return iterator(this, "entries", (value) => { + value[1] = toWrapped(this, value[1]); + return value; + }); + }, + every(fn, thisArg) { + return apply(this, "every", fn, thisArg, void 0, arguments); + }, + filter(fn, thisArg) { + return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments); + }, + find(fn, thisArg) { + return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments); + }, + findIndex(fn, thisArg) { + return apply(this, "findIndex", fn, thisArg, void 0, arguments); + }, + findLast(fn, thisArg) { + return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments); + }, + findLastIndex(fn, thisArg) { + return apply(this, "findLastIndex", fn, thisArg, void 0, arguments); + }, + forEach(fn, thisArg) { + return apply(this, "forEach", fn, thisArg, void 0, arguments); + }, + includes(...args) { + return searchProxy(this, "includes", args); + }, + indexOf(...args) { + return searchProxy(this, "indexOf", args); + }, + join(separator) { + return reactiveReadArray(this).join(separator); + }, + lastIndexOf(...args) { + return searchProxy(this, "lastIndexOf", args); + }, + map(fn, thisArg) { + return apply(this, "map", fn, thisArg, void 0, arguments); + }, + pop() { + return noTracking(this, "pop"); + }, + push(...args) { + return noTracking(this, "push", args); + }, + reduce(fn, ...args) { + return reduce(this, "reduce", fn, args); + }, + reduceRight(fn, ...args) { + return reduce(this, "reduceRight", fn, args); + }, + shift() { + return noTracking(this, "shift"); + }, + some(fn, thisArg) { + return apply(this, "some", fn, thisArg, void 0, arguments); + }, + splice(...args) { + return noTracking(this, "splice", args); + }, + toReversed() { + return reactiveReadArray(this).toReversed(); + }, + toSorted(comparer) { + return reactiveReadArray(this).toSorted(comparer); + }, + toSpliced(...args) { + return reactiveReadArray(this).toSpliced(...args); + }, + unshift(...args) { + return noTracking(this, "unshift", args); + }, + values() { + return iterator(this, "values", (item) => toWrapped(this, item)); + } +}; +function iterator(self, method, wrapValue) { + const arr = shallowReadArray(self); + const iter = arr[method](); + if (arr !== self && !/* @__PURE__ */ isShallow(self)) { + iter._next = iter.next; + iter.next = () => { + const result = iter._next(); + if (!result.done) result.value = wrapValue(result.value); + return result; + }; + } + return iter; +} +var arrayProto = Array.prototype; +function apply(self, method, fn, thisArg, wrappedRetFn, args) { + const arr = shallowReadArray(self); + const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self); + const methodFn = arr[method]; + if (methodFn !== arrayProto[method]) { + const result2 = methodFn.apply(self, args); + return needsWrap ? toReactive(result2) : result2; + } + let wrappedFn = fn; + if (arr !== self) { + if (needsWrap) wrappedFn = function(item, index) { + return fn.call(this, toWrapped(self, item), index, self); + }; + else if (fn.length > 2) wrappedFn = function(item, index) { + return fn.call(this, item, index, self); + }; + } + const result = methodFn.call(arr, wrappedFn, thisArg); + return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result; +} +function reduce(self, method, fn, args) { + const arr = shallowReadArray(self); + const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self); + let wrappedFn = fn; + let wrapInitialAccumulator = false; + if (arr !== self) { + if (needsWrap) { + wrapInitialAccumulator = args.length === 0; + wrappedFn = function(acc, item, index) { + if (wrapInitialAccumulator) { + wrapInitialAccumulator = false; + acc = toWrapped(self, acc); + } + return fn.call(this, acc, toWrapped(self, item), index, self); + }; + } else if (fn.length > 3) wrappedFn = function(acc, item, index) { + return fn.call(this, acc, item, index, self); + }; + } + const result = arr[method](wrappedFn, ...args); + return wrapInitialAccumulator ? toWrapped(self, result) : result; +} +function searchProxy(self, method, args) { + const arr = /* @__PURE__ */ toRaw(self); + track(arr, "iterate", ARRAY_ITERATE_KEY); + const res = arr[method](...args); + if ((res === -1 || res === false) && /* @__PURE__ */ isProxy(args[0])) { + args[0] = /* @__PURE__ */ toRaw(args[0]); + return arr[method](...args); + } + return res; +} +function noTracking(self, method, args = []) { + pauseTracking(); + startBatch(); + const res = (/* @__PURE__ */ toRaw(self))[method].apply(self, args); + endBatch(); + resetTracking(); + return res; +} +var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`); +var builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)); +function hasOwnProperty(key) { + if (!isSymbol(key)) key = String(key); + const obj = /* @__PURE__ */ toRaw(this); + track(obj, "has", key); + return obj.hasOwnProperty(key); +} +var BaseReactiveHandler = class { + constructor(_isReadonly = false, _isShallow = false) { + this._isReadonly = _isReadonly; + this._isShallow = _isShallow; + } + get(target, key, receiver) { + if (key === "__v_skip") return target["__v_skip"]; + const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow; + if (key === "__v_isReactive") return !isReadonly2; + else if (key === "__v_isReadonly") return isReadonly2; + else if (key === "__v_isShallow") return isShallow2; + else if (key === "__v_raw") { + if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) return target; + return; + } + const targetIsArray = isArray(target); + if (!isReadonly2) { + let fn; + if (targetIsArray && (fn = arrayInstrumentations[key])) return fn; + if (key === "hasOwnProperty") return hasOwnProperty; + } + const res = Reflect.get(target, key, /* @__PURE__ */ isRef(target) ? target : receiver); + if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) return res; + if (!isReadonly2) track(target, "get", key); + if (isShallow2) return res; + if (/* @__PURE__ */ isRef(res)) { + const value = targetIsArray && isIntegerKey(key) ? res : res.value; + return isReadonly2 && isObject(value) ? /* @__PURE__ */ readonly(value) : value; + } + if (isObject(res)) return isReadonly2 ? /* @__PURE__ */ readonly(res) : /* @__PURE__ */ reactive(res); + return res; + } +}; +var MutableReactiveHandler = class extends BaseReactiveHandler { + constructor(isShallow2 = false) { + super(false, isShallow2); + } + set(target, key, value, receiver) { + let oldValue = target[key]; + const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key); + if (!this._isShallow) { + const isOldValueReadonly = /* @__PURE__ */ isReadonly(oldValue); + if (!/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) { + oldValue = /* @__PURE__ */ toRaw(oldValue); + value = /* @__PURE__ */ toRaw(value); + } + if (!isArrayWithIntegerKey && /* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) if (isOldValueReadonly) { + warn$2(`Set operation on key "${String(key)}" failed: target is readonly.`, target[key]); + return true; + } else { + oldValue.value = value; + return true; + } + } + const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key); + const result = Reflect.set(target, key, value, /* @__PURE__ */ isRef(target) ? target : receiver); + if (target === /* @__PURE__ */ toRaw(receiver) && result) { + if (!hadKey) trigger(target, "add", key, value); + else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue); + } + return result; + } + deleteProperty(target, key) { + const hadKey = hasOwn(target, key); + const oldValue = target[key]; + const result = Reflect.deleteProperty(target, key); + if (result && hadKey) trigger(target, "delete", key, void 0, oldValue); + return result; + } + has(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol(key) || !builtInSymbols.has(key)) track(target, "has", key); + return result; + } + ownKeys(target) { + track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY); + return Reflect.ownKeys(target); + } +}; +var ReadonlyReactiveHandler = class extends BaseReactiveHandler { + constructor(isShallow2 = false) { + super(true, isShallow2); + } + set(target, key) { + warn$2(`Set operation on key "${String(key)}" failed: target is readonly.`, target); + return true; + } + deleteProperty(target, key) { + warn$2(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); + return true; + } +}; +var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler(); +var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(); +var shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true); +var shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true); +var toShallow = (value) => value; +var getProto = (v) => Reflect.getPrototypeOf(v); +function createIterableMethod(method, isReadonly2, isShallow2) { + return function(...args) { + const target = this["__v_raw"]; + const rawTarget = /* @__PURE__ */ toRaw(target); + const targetIsMap = isMap(rawTarget); + const isPair = method === "entries" || method === Symbol.iterator && targetIsMap; + const isKeyOnly = method === "keys" && targetIsMap; + const innerIterator = target[method](...args); + const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; + !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); + return extend(Object.create(innerIterator), { next() { + const { value, done } = innerIterator.next(); + return done ? { + value, + done + } : { + value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), + done + }; + } }); + }; +} +function createReadonlyMethod(type) { + return function(...args) { + { + const key = args[0] ? `on key "${args[0]}" ` : ``; + warn$2(`${capitalize(type)} operation ${key}failed: target is readonly.`, /* @__PURE__ */ toRaw(this)); + } + return type === "delete" ? false : type === "clear" ? void 0 : this; + }; +} +function createInstrumentations(readonly, shallow) { + const instrumentations = { + get(key) { + const target = this["__v_raw"]; + const rawTarget = /* @__PURE__ */ toRaw(target); + const rawKey = /* @__PURE__ */ toRaw(key); + if (!readonly) { + if (hasChanged(key, rawKey)) track(rawTarget, "get", key); + track(rawTarget, "get", rawKey); + } + const { has } = getProto(rawTarget); + const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive; + if (has.call(rawTarget, key)) return wrap(target.get(key)); + else if (has.call(rawTarget, rawKey)) return wrap(target.get(rawKey)); + else if (target !== rawTarget) target.get(key); + }, + get size() { + const target = this["__v_raw"]; + !readonly && track(/* @__PURE__ */ toRaw(target), "iterate", ITERATE_KEY); + return target.size; + }, + has(key) { + const target = this["__v_raw"]; + const rawTarget = /* @__PURE__ */ toRaw(target); + const rawKey = /* @__PURE__ */ toRaw(key); + if (!readonly) { + if (hasChanged(key, rawKey)) track(rawTarget, "has", key); + track(rawTarget, "has", rawKey); + } + return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); + }, + forEach(callback, thisArg) { + const observed = this; + const target = observed["__v_raw"]; + const rawTarget = /* @__PURE__ */ toRaw(target); + const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive; + !readonly && track(rawTarget, "iterate", ITERATE_KEY); + return target.forEach((value, key) => { + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + } + }; + extend(instrumentations, readonly ? { + add: createReadonlyMethod("add"), + set: createReadonlyMethod("set"), + delete: createReadonlyMethod("delete"), + clear: createReadonlyMethod("clear") + } : { + add(value) { + const target = /* @__PURE__ */ toRaw(this); + const proto = getProto(target); + const rawValue = /* @__PURE__ */ toRaw(value); + const valueToAdd = !shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value) ? rawValue : value; + if (!(proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue))) { + target.add(valueToAdd); + trigger(target, "add", valueToAdd, valueToAdd); + } + return this; + }, + set(key, value) { + if (!shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) value = /* @__PURE__ */ toRaw(value); + const target = /* @__PURE__ */ toRaw(this); + const { has, get } = getProto(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = /* @__PURE__ */ toRaw(key); + hadKey = has.call(target, key); + } else checkIdentityKeys(target, has, key); + const oldValue = get.call(target, key); + target.set(key, value); + if (!hadKey) trigger(target, "add", key, value); + else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue); + return this; + }, + delete(key) { + const target = /* @__PURE__ */ toRaw(this); + const { has, get } = getProto(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = /* @__PURE__ */ toRaw(key); + hadKey = has.call(target, key); + } else checkIdentityKeys(target, has, key); + const oldValue = get ? get.call(target, key) : void 0; + const result = target.delete(key); + if (hadKey) trigger(target, "delete", key, void 0, oldValue); + return result; + }, + clear() { + const target = /* @__PURE__ */ toRaw(this); + const hadItems = target.size !== 0; + const oldTarget = isMap(target) ? new Map(target) : new Set(target); + const result = target.clear(); + if (hadItems) trigger(target, "clear", void 0, void 0, oldTarget); + return result; + } + }); + [ + "keys", + "values", + "entries", + Symbol.iterator + ].forEach((method) => { + instrumentations[method] = createIterableMethod(method, readonly, shallow); + }); + return instrumentations; +} +function createInstrumentationGetter(isReadonly2, shallow) { + const instrumentations = createInstrumentations(isReadonly2, shallow); + return (target, key, receiver) => { + if (key === "__v_isReactive") return !isReadonly2; + else if (key === "__v_isReadonly") return isReadonly2; + else if (key === "__v_raw") return target; + return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver); + }; +} +var mutableCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, false) }; +var shallowCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, true) }; +var readonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, false) }; +var shallowReadonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, true) }; +function checkIdentityKeys(target, has, key) { + const rawKey = /* @__PURE__ */ toRaw(key); + if (rawKey !== key && has.call(target, rawKey)) { + const type = toRawType(target); + warn$2(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`); + } +} +var reactiveMap = /* @__PURE__ */ new WeakMap(); +var shallowReactiveMap = /* @__PURE__ */ new WeakMap(); +var readonlyMap = /* @__PURE__ */ new WeakMap(); +var shallowReadonlyMap = /* @__PURE__ */ new WeakMap(); +function targetTypeMap(rawType) { + switch (rawType) { + case "Object": + case "Array": return 1; + case "Map": + case "Set": + case "WeakMap": + case "WeakSet": return 2; + default: return 0; + } +} +// @__NO_SIDE_EFFECTS__ +function reactive(target) { + if (/* @__PURE__ */ isReadonly(target)) return target; + return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); +} +// @__NO_SIDE_EFFECTS__ +function shallowReactive(target) { + return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); +} +// @__NO_SIDE_EFFECTS__ +function readonly(target) { + return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); +} +// @__NO_SIDE_EFFECTS__ +function shallowReadonly(target) { + return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap); +} +function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) { + if (!isObject(target)) { + warn$2(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`); + return target; + } + if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) return target; + if (target["__v_skip"] || !Object.isExtensible(target)) return target; + const existingProxy = proxyMap.get(target); + if (existingProxy) return existingProxy; + const targetType = targetTypeMap(toRawType(target)); + if (targetType === 0) return target; + const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers); + proxyMap.set(target, proxy); + return proxy; +} +// @__NO_SIDE_EFFECTS__ +function isReactive(value) { + if (/* @__PURE__ */ isReadonly(value)) return /* @__PURE__ */ isReactive(value["__v_raw"]); + return !!(value && value["__v_isReactive"]); +} +// @__NO_SIDE_EFFECTS__ +function isReadonly(value) { + return !!(value && value["__v_isReadonly"]); +} +// @__NO_SIDE_EFFECTS__ +function isShallow(value) { + return !!(value && value["__v_isShallow"]); +} +// @__NO_SIDE_EFFECTS__ +function isProxy(value) { + return value ? !!value["__v_raw"] : false; +} +// @__NO_SIDE_EFFECTS__ +function toRaw(observed) { + const raw = observed && observed["__v_raw"]; + return raw ? /* @__PURE__ */ toRaw(raw) : observed; +} +function markRaw(value) { + if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) def(value, "__v_skip", true); + return value; +} +var toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value; +var toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value; +// @__NO_SIDE_EFFECTS__ +function isRef(r) { + return r ? r["__v_isRef"] === true : false; +} +// @__NO_SIDE_EFFECTS__ +function ref(value) { + return createRef(value, false); +} +// @__NO_SIDE_EFFECTS__ +function shallowRef(value) { + return createRef(value, true); +} +function createRef(rawValue, shallow) { + if (/* @__PURE__ */ isRef(rawValue)) return rawValue; + return new RefImpl(rawValue, shallow); +} +var RefImpl = class { + constructor(value, isShallow2) { + this.dep = new Dep(); + this["__v_isRef"] = true; + this["__v_isShallow"] = false; + this._rawValue = isShallow2 ? value : /* @__PURE__ */ toRaw(value); + this._value = isShallow2 ? value : toReactive(value); + this["__v_isShallow"] = isShallow2; + } + get value() { + this.dep.track({ + target: this, + type: "get", + key: "value" + }); + return this._value; + } + set value(newValue) { + const oldValue = this._rawValue; + const useDirectValue = this["__v_isShallow"] || /* @__PURE__ */ isShallow(newValue) || /* @__PURE__ */ isReadonly(newValue); + newValue = useDirectValue ? newValue : /* @__PURE__ */ toRaw(newValue); + if (hasChanged(newValue, oldValue)) { + this._rawValue = newValue; + this._value = useDirectValue ? newValue : toReactive(newValue); + this.dep.trigger({ + target: this, + type: "set", + key: "value", + newValue, + oldValue + }); + } + } +}; +function triggerRef(ref2) { + if (ref2.dep) ref2.dep.trigger({ + target: ref2, + type: "set", + key: "value", + newValue: ref2._value + }); +} +function unref(ref2) { + return /* @__PURE__ */ isRef(ref2) ? ref2.value : ref2; +} +function toValue(source) { + return isFunction(source) ? source() : unref(source); +} +var shallowUnwrapHandlers = { + get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)), + set: (target, key, value, receiver) => { + const oldValue = target[key]; + if (/* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) { + oldValue.value = value; + return true; + } else return Reflect.set(target, key, value, receiver); + } +}; +function proxyRefs(objectWithRefs) { + return /* @__PURE__ */ isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers); +} +var CustomRefImpl = class { + constructor(factory) { + this["__v_isRef"] = true; + this._value = void 0; + const dep = this.dep = new Dep(); + const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep)); + this._get = get; + this._set = set; + } + get value() { + return this._value = this._get(); + } + set value(newVal) { + this._set(newVal); + } +}; +function customRef(factory) { + return new CustomRefImpl(factory); +} +// @__NO_SIDE_EFFECTS__ +function toRefs(object) { + if (!/* @__PURE__ */ isProxy(object)) warn$2(`toRefs() expects a reactive object but received a plain one.`); + const ret = isArray(object) ? new Array(object.length) : {}; + for (const key in object) ret[key] = propertyToRef(object, key); + return ret; +} +var ObjectRefImpl = class { + constructor(_object, key, _defaultValue) { + this._object = _object; + this._defaultValue = _defaultValue; + this["__v_isRef"] = true; + this._value = void 0; + this._key = isSymbol(key) ? key : String(key); + this._raw = /* @__PURE__ */ toRaw(_object); + let shallow = true; + let obj = _object; + if (!isArray(_object) || isSymbol(this._key) || !isIntegerKey(this._key)) do + shallow = !/* @__PURE__ */ isProxy(obj) || /* @__PURE__ */ isShallow(obj); + while (shallow && (obj = obj["__v_raw"])); + this._shallow = shallow; + } + get value() { + let val = this._object[this._key]; + if (this._shallow) val = unref(val); + return this._value = val === void 0 ? this._defaultValue : val; + } + set value(newVal) { + if (this._shallow && /* @__PURE__ */ isRef(this._raw[this._key])) { + const nestedRef = this._object[this._key]; + if (/* @__PURE__ */ isRef(nestedRef)) { + nestedRef.value = newVal; + return; + } + } + this._object[this._key] = newVal; + } + get dep() { + return getDepFromReactive(this._raw, this._key); + } +}; +var GetterRefImpl = class { + constructor(_getter) { + this._getter = _getter; + this["__v_isRef"] = true; + this["__v_isReadonly"] = true; + this._value = void 0; + } + get value() { + return this._value = this._getter(); + } +}; +// @__NO_SIDE_EFFECTS__ +function toRef(source, key, defaultValue) { + if (/* @__PURE__ */ isRef(source)) return source; + else if (isFunction(source)) return new GetterRefImpl(source); + else if (isObject(source) && arguments.length > 1) return propertyToRef(source, key, defaultValue); + else return /* @__PURE__ */ ref(source); +} +function propertyToRef(source, key, defaultValue) { + return new ObjectRefImpl(source, key, defaultValue); +} +var ComputedRefImpl = class { + constructor(fn, setter, isSSR) { + this.fn = fn; + this.setter = setter; + /** + * @internal + */ + this._value = void 0; + /** + * @internal + */ + this.dep = new Dep(this); + /** + * @internal + */ + this.__v_isRef = true; + /** + * @internal + */ + this.deps = void 0; + /** + * @internal + */ + this.depsTail = void 0; + /** + * @internal + */ + this.flags = 16; + /** + * @internal + */ + this.globalVersion = globalVersion - 1; + /** + * @internal + */ + this.next = void 0; + this.effect = this; + this["__v_isReadonly"] = !setter; + this.isSSR = isSSR; + } + /** + * @internal + */ + notify() { + this.flags |= 16; + if (!(this.flags & 8) && activeSub !== this) { + batch(this, true); + return true; + } + } + get value() { + const link = this.dep.track({ + target: this, + type: "get", + key: "value" + }); + refreshComputed(this); + if (link) link.version = this.dep.version; + return this._value; + } + set value(newValue) { + if (this.setter) this.setter(newValue); + else warn$2("Write operation failed: computed value is readonly"); + } +}; +// @__NO_SIDE_EFFECTS__ +function computed$1(getterOrOptions, debugOptions, isSSR = false) { + let getter; + let setter; + if (isFunction(getterOrOptions)) getter = getterOrOptions; + else { + getter = getterOrOptions.get; + setter = getterOrOptions.set; + } + const cRef = new ComputedRefImpl(getter, setter, isSSR); + if (debugOptions && !isSSR) { + cRef.onTrack = debugOptions.onTrack; + cRef.onTrigger = debugOptions.onTrigger; + } + return cRef; +} +var TrackOpTypes = { + "GET": "get", + "HAS": "has", + "ITERATE": "iterate" +}; +var TriggerOpTypes = { + "SET": "set", + "ADD": "add", + "DELETE": "delete", + "CLEAR": "clear" +}; +var INITIAL_WATCHER_VALUE = {}; +var cleanupMap = /* @__PURE__ */ new WeakMap(); +var activeWatcher = void 0; +function getCurrentWatcher() { + return activeWatcher; +} +function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) { + if (owner) { + let cleanups = cleanupMap.get(owner); + if (!cleanups) cleanupMap.set(owner, cleanups = []); + cleanups.push(cleanupFn); + } else if (!failSilently) warn$2(`onWatcherCleanup() was called when there was no active watcher to associate with.`); +} +function watch$1(source, cb, options = EMPTY_OBJ) { + const { immediate, deep, once, scheduler, augmentJob, call } = options; + const warnInvalidSource = (s) => { + (options.onWarn || warn$2)(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`); + }; + const reactiveGetter = (source2) => { + if (deep) return source2; + if (/* @__PURE__ */ isShallow(source2) || deep === false || deep === 0) return traverse(source2, 1); + return traverse(source2); + }; + let effect; + let getter; + let cleanup; + let boundCleanup; + let forceTrigger = false; + let isMultiSource = false; + if (/* @__PURE__ */ isRef(source)) { + getter = () => source.value; + forceTrigger = /* @__PURE__ */ isShallow(source); + } else if (/* @__PURE__ */ isReactive(source)) { + getter = () => reactiveGetter(source); + forceTrigger = true; + } else if (isArray(source)) { + isMultiSource = true; + forceTrigger = source.some((s) => /* @__PURE__ */ isReactive(s) || /* @__PURE__ */ isShallow(s)); + getter = () => source.map((s) => { + if (/* @__PURE__ */ isRef(s)) return s.value; + else if (/* @__PURE__ */ isReactive(s)) return reactiveGetter(s); + else if (isFunction(s)) return call ? call(s, 2) : s(); + else warnInvalidSource(s); + }); + } else if (isFunction(source)) if (cb) getter = call ? () => call(source, 2) : source; + else getter = () => { + if (cleanup) { + pauseTracking(); + try { + cleanup(); + } finally { + resetTracking(); + } + } + const currentEffect = activeWatcher; + activeWatcher = effect; + try { + return call ? call(source, 3, [boundCleanup]) : source(boundCleanup); + } finally { + activeWatcher = currentEffect; + } + }; + else { + getter = NOOP; + warnInvalidSource(source); + } + if (cb && deep) { + const baseGetter = getter; + const depth = deep === true ? Infinity : deep; + getter = () => traverse(baseGetter(), depth); + } + const scope = getCurrentScope(); + const watchHandle = () => { + effect.stop(); + if (scope && scope.active) remove(scope.effects, effect); + }; + if (once && cb) { + const _cb = cb; + cb = (...args) => { + const res = _cb(...args); + watchHandle(); + return res; + }; + } + let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE; + const job = (immediateFirstRun) => { + if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) return; + if (cb) { + const newValue = effect.run(); + if (immediateFirstRun || deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) { + if (cleanup) cleanup(); + const currentWatcher = activeWatcher; + activeWatcher = effect; + try { + const args = [ + newValue, + oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue, + boundCleanup + ]; + oldValue = newValue; + call ? call(cb, 3, args) : cb(...args); + } finally { + activeWatcher = currentWatcher; + } + } + } else effect.run(); + }; + if (augmentJob) augmentJob(job); + effect = new ReactiveEffect(getter); + effect.scheduler = scheduler ? () => scheduler(job, false) : job; + boundCleanup = (fn) => onWatcherCleanup(fn, false, effect); + cleanup = effect.onStop = () => { + const cleanups = cleanupMap.get(effect); + if (cleanups) { + if (call) call(cleanups, 4); + else for (const cleanup2 of cleanups) cleanup2(); + cleanupMap.delete(effect); + } + }; + effect.onTrack = options.onTrack; + effect.onTrigger = options.onTrigger; + if (cb) if (immediate) job(true); + else oldValue = effect.run(); + else if (scheduler) scheduler(job.bind(null, true), true); + else effect.run(); + watchHandle.pause = effect.pause.bind(effect); + watchHandle.resume = effect.resume.bind(effect); + watchHandle.stop = watchHandle; + return watchHandle; +} +function traverse(value, depth = Infinity, seen) { + if (depth <= 0 || !isObject(value) || value["__v_skip"]) return value; + seen = seen || /* @__PURE__ */ new Map(); + if ((seen.get(value) || 0) >= depth) return value; + seen.set(value, depth); + depth--; + if (/* @__PURE__ */ isRef(value)) traverse(value.value, depth, seen); + else if (isArray(value)) for (let i = 0; i < value.length; i++) traverse(value[i], depth, seen); + else if (isSet(value) || isMap(value)) value.forEach((v) => { + traverse(v, depth, seen); + }); + else if (isPlainObject(value)) { + for (const key in value) traverse(value[key], depth, seen); + for (const key of Object.getOwnPropertySymbols(value)) if (Object.prototype.propertyIsEnumerable.call(value, key)) traverse(value[key], depth, seen); + } + return value; +} +//#endregion +//#region node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js +/** +* @vue/runtime-core v3.5.39 +* (c) 2018-present Yuxi (Evan) You and Vue contributors +* @license MIT +**/ +var stack = []; +function pushWarningContext(vnode) { + stack.push(vnode); +} +function popWarningContext() { + stack.pop(); +} +var isWarning = false; +function warn$1(msg, ...args) { + if (isWarning) return; + isWarning = true; + pauseTracking(); + const instance = stack.length ? stack[stack.length - 1].component : null; + const appWarnHandler = instance && instance.appContext.config.warnHandler; + const trace = getComponentTrace(); + if (appWarnHandler) callWithErrorHandling(appWarnHandler, instance, 11, [ + msg + args.map((a) => { + var _a, _b; + return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a); + }).join(""), + instance && instance.proxy, + trace.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`).join("\n"), + trace + ]); + else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args]; + if (trace.length && true) warnArgs.push(` +`, ...formatTrace(trace)); + console.warn(...warnArgs); + } + resetTracking(); + isWarning = false; +} +function getComponentTrace() { + let currentVNode = stack[stack.length - 1]; + if (!currentVNode) return []; + const normalizedStack = []; + while (currentVNode) { + const last = normalizedStack[0]; + if (last && last.vnode === currentVNode) last.recurseCount++; + else normalizedStack.push({ + vnode: currentVNode, + recurseCount: 0 + }); + const parentInstance = currentVNode.component && currentVNode.component.parent; + currentVNode = parentInstance && parentInstance.vnode; + } + return normalizedStack; +} +function formatTrace(trace) { + const logs = []; + trace.forEach((entry, i) => { + logs.push(...i === 0 ? [] : [` +`], ...formatTraceEntry(entry)); + }); + return logs; +} +function formatTraceEntry({ vnode, recurseCount }) { + const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; + const isRoot = vnode.component ? vnode.component.parent == null : false; + const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`; + const close = `>` + postfix; + return vnode.props ? [ + open, + ...formatProps(vnode.props), + close + ] : [open + close]; +} +function formatProps(props) { + const res = []; + const keys = Object.keys(props); + keys.slice(0, 3).forEach((key) => { + res.push(...formatProp(key, props[key])); + }); + if (keys.length > 3) res.push(` ...`); + return res; +} +function formatProp(key, value, raw) { + if (isString(value)) { + value = JSON.stringify(value); + return raw ? value : [`${key}=${value}`]; + } else if (typeof value === "number" || typeof value === "boolean" || value == null) return raw ? value : [`${key}=${value}`]; + else if (/* @__PURE__ */ isRef(value)) { + value = formatProp(key, /* @__PURE__ */ toRaw(value.value), true); + return raw ? value : [ + `${key}=Ref<`, + value, + `>` + ]; + } else if (isFunction(value)) return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; + else { + value = /* @__PURE__ */ toRaw(value); + return raw ? value : [`${key}=`, value]; + } +} +function assertNumber(val, type) { + if (val === void 0) return; + else if (typeof val !== "number") warn$1(`${type} is not a valid number - got ${JSON.stringify(val)}.`); + else if (isNaN(val)) warn$1(`${type} is NaN - the duration expression might be incorrect.`); +} +var ErrorCodes = { + "SETUP_FUNCTION": 0, + "0": "SETUP_FUNCTION", + "RENDER_FUNCTION": 1, + "1": "RENDER_FUNCTION", + "NATIVE_EVENT_HANDLER": 5, + "5": "NATIVE_EVENT_HANDLER", + "COMPONENT_EVENT_HANDLER": 6, + "6": "COMPONENT_EVENT_HANDLER", + "VNODE_HOOK": 7, + "7": "VNODE_HOOK", + "DIRECTIVE_HOOK": 8, + "8": "DIRECTIVE_HOOK", + "TRANSITION_HOOK": 9, + "9": "TRANSITION_HOOK", + "APP_ERROR_HANDLER": 10, + "10": "APP_ERROR_HANDLER", + "APP_WARN_HANDLER": 11, + "11": "APP_WARN_HANDLER", + "FUNCTION_REF": 12, + "12": "FUNCTION_REF", + "ASYNC_COMPONENT_LOADER": 13, + "13": "ASYNC_COMPONENT_LOADER", + "SCHEDULER": 14, + "14": "SCHEDULER", + "COMPONENT_UPDATE": 15, + "15": "COMPONENT_UPDATE", + "APP_UNMOUNT_CLEANUP": 16, + "16": "APP_UNMOUNT_CLEANUP" +}; +var ErrorTypeStrings$1 = { + ["sp"]: "serverPrefetch hook", + ["bc"]: "beforeCreate hook", + ["c"]: "created hook", + ["bm"]: "beforeMount hook", + ["m"]: "mounted hook", + ["bu"]: "beforeUpdate hook", + ["u"]: "updated", + ["bum"]: "beforeUnmount hook", + ["um"]: "unmounted hook", + ["a"]: "activated hook", + ["da"]: "deactivated hook", + ["ec"]: "errorCaptured hook", + ["rtc"]: "renderTracked hook", + ["rtg"]: "renderTriggered hook", + [0]: "setup function", + [1]: "render function", + [2]: "watcher getter", + [3]: "watcher callback", + [4]: "watcher cleanup function", + [5]: "native event handler", + [6]: "component event handler", + [7]: "vnode hook", + [8]: "directive hook", + [9]: "transition hook", + [10]: "app errorHandler", + [11]: "app warnHandler", + [12]: "ref function", + [13]: "async component loader", + [14]: "scheduler flush", + [15]: "component update", + [16]: "app unmount cleanup function" +}; +function callWithErrorHandling(fn, instance, type, args) { + try { + return args ? fn(...args) : fn(); + } catch (err) { + handleError(err, instance, type); + } +} +function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction(fn)) { + const res = callWithErrorHandling(fn, instance, type, args); + if (res && isPromise(res)) res.catch((err) => { + handleError(err, instance, type); + }); + return res; + } + if (isArray(fn)) { + const values = []; + for (let i = 0; i < fn.length; i++) values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); + return values; + } else warn$1(`Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`); +} +function handleError(err, instance, type, throwInDev = true) { + const contextVNode = instance ? instance.vnode : null; + const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ; + if (instance) { + let cur = instance.parent; + const exposedInstance = instance.proxy; + const errorInfo = ErrorTypeStrings$1[type]; + while (cur) { + const errorCapturedHooks = cur.ec; + if (errorCapturedHooks) { + for (let i = 0; i < errorCapturedHooks.length; i++) if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) return; + } + cur = cur.parent; + } + if (errorHandler) { + pauseTracking(); + callWithErrorHandling(errorHandler, null, 10, [ + err, + exposedInstance, + errorInfo + ]); + resetTracking(); + return; + } + } + logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction); +} +function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) { + { + const info = ErrorTypeStrings$1[type]; + if (contextVNode) pushWarningContext(contextVNode); + warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`); + if (contextVNode) popWarningContext(); + if (throwInDev) throw err; + else console.error(err); + } +} +var queue = []; +var flushIndex = -1; +var pendingPostFlushCbs = []; +var activePostFlushCbs = null; +var postFlushIndex = 0; +var resolvedPromise = /* @__PURE__ */ Promise.resolve(); +var currentFlushPromise = null; +var RECURSION_LIMIT = 100; +function nextTick(fn) { + const p = currentFlushPromise || resolvedPromise; + return fn ? p.then(this ? fn.bind(this) : fn) : p; +} +function findInsertionIndex(id) { + let start = flushIndex + 1; + let end = queue.length; + while (start < end) { + const middle = start + end >>> 1; + const middleJob = queue[middle]; + const middleJobId = getId(middleJob); + if (middleJobId < id || middleJobId === id && middleJob.flags & 2) start = middle + 1; + else end = middle; + } + return start; +} +function queueJob(job) { + if (!(job.flags & 1)) { + const jobId = getId(job); + const lastJob = queue[queue.length - 1]; + if (!lastJob || !(job.flags & 2) && jobId >= getId(lastJob)) queue.push(job); + else queue.splice(findInsertionIndex(jobId), 0, job); + job.flags |= 1; + queueFlush(); + } +} +function queueFlush() { + if (!currentFlushPromise) currentFlushPromise = resolvedPromise.then(flushJobs); +} +function queuePostFlushCb(cb) { + if (!isArray(cb)) { + if (activePostFlushCbs && cb.id === -1) activePostFlushCbs.splice(postFlushIndex + 1, 0, cb); + else if (!(cb.flags & 1)) { + pendingPostFlushCbs.push(cb); + cb.flags |= 1; + } + } else pendingPostFlushCbs.push(...cb); + queueFlush(); +} +function flushPreFlushCbs(instance, seen, i = flushIndex + 1) { + seen = seen || /* @__PURE__ */ new Map(); + for (; i < queue.length; i++) { + const cb = queue[i]; + if (cb && cb.flags & 2) { + if (instance && cb.id !== instance.uid) continue; + if (checkRecursiveUpdates(seen, cb)) continue; + queue.splice(i, 1); + i--; + if (cb.flags & 4) cb.flags &= -2; + cb(); + if (!(cb.flags & 4)) cb.flags &= -2; + } + } +} +function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + const deduped = [...new Set(pendingPostFlushCbs)].sort((a, b) => getId(a) - getId(b)); + pendingPostFlushCbs.length = 0; + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped); + return; + } + activePostFlushCbs = deduped; + seen = seen || /* @__PURE__ */ new Map(); + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + const cb = activePostFlushCbs[postFlushIndex]; + if (checkRecursiveUpdates(seen, cb)) continue; + if (cb.flags & 4) cb.flags &= -2; + if (!(cb.flags & 8)) cb(); + cb.flags &= -2; + } + activePostFlushCbs = null; + postFlushIndex = 0; + } +} +var getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id; +function flushJobs(seen) { + seen = seen || /* @__PURE__ */ new Map(); + const check = (job) => checkRecursiveUpdates(seen, job); + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job && !(job.flags & 8)) { + if (check(job)) continue; + if (job.flags & 4) job.flags &= -2; + callWithErrorHandling(job, job.i, job.i ? 15 : 14); + if (!(job.flags & 4)) job.flags &= -2; + } + } + } finally { + for (; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job) job.flags &= -2; + } + flushIndex = -1; + queue.length = 0; + flushPostFlushCbs(seen); + currentFlushPromise = null; + if (queue.length || pendingPostFlushCbs.length) flushJobs(seen); + } +} +function checkRecursiveUpdates(seen, fn) { + const count = seen.get(fn) || 0; + if (count > RECURSION_LIMIT) { + const instance = fn.i; + const componentName = instance && getComponentName(instance.type); + handleError(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`, null, 10); + return true; + } + seen.set(fn, count + 1); + return false; +} +var isHmrUpdating = false; +var setHmrUpdating = (v) => { + try { + return isHmrUpdating; + } finally { + isHmrUpdating = v; + } +}; +var hmrDirtyComponents = /* @__PURE__ */ new Map(); +getGlobalThis().__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap(createRecord), + rerender: tryWrap(rerender), + reload: tryWrap(reload) +}; +var map = /* @__PURE__ */ new Map(); +function registerHMR(instance) { + const id = instance.type.__hmrId; + let record = map.get(id); + if (!record) { + createRecord(id, instance.type); + record = map.get(id); + } + record.instances.add(instance); +} +function unregisterHMR(instance) { + map.get(instance.type.__hmrId).instances.delete(instance); +} +function createRecord(id, initialDef) { + if (map.has(id)) return false; + map.set(id, { + initialDef: normalizeClassComponent(initialDef), + instances: /* @__PURE__ */ new Set() + }); + return true; +} +function normalizeClassComponent(component) { + return isClassComponent(component) ? component.__vccOpts : component; +} +function rerender(id, newRender) { + const record = map.get(id); + if (!record) return; + record.initialDef.render = newRender; + [...record.instances].forEach((instance) => { + if (newRender) { + instance.render = newRender; + normalizeClassComponent(instance.type).render = newRender; + } + instance.renderCache = []; + isHmrUpdating = true; + if (!(instance.job.flags & 8)) instance.update(); + isHmrUpdating = false; + }); +} +function reload(id, newComp) { + const record = map.get(id); + if (!record) return; + newComp = normalizeClassComponent(newComp); + updateComponentDef(record.initialDef, newComp); + const instances = [...record.instances]; + for (let i = 0; i < instances.length; i++) { + const instance = instances[i]; + const oldComp = normalizeClassComponent(instance.type); + let dirtyInstances = hmrDirtyComponents.get(oldComp); + if (!dirtyInstances) { + if (oldComp !== record.initialDef) updateComponentDef(oldComp, newComp); + hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set()); + } + dirtyInstances.add(instance); + instance.appContext.propsCache.delete(instance.type); + instance.appContext.emitsCache.delete(instance.type); + instance.appContext.optionsCache.delete(instance.type); + if (instance.ceReload) { + dirtyInstances.add(instance); + instance.ceReload(newComp.styles); + dirtyInstances.delete(instance); + } else if (instance.parent) queueJob(() => { + if (!(instance.job.flags & 8)) { + isHmrUpdating = true; + instance.parent.update(); + isHmrUpdating = false; + dirtyInstances.delete(instance); + } + }); + else if (instance.appContext.reload) instance.appContext.reload(); + else if (typeof window !== "undefined") window.location.reload(); + else console.warn("[HMR] Root or manually mounted instance modified. Full reload required."); + if (instance.root.ce && instance !== instance.root) instance.root.ce._removeChildStyle(oldComp); + } + queuePostFlushCb(() => { + hmrDirtyComponents.clear(); + }); +} +function updateComponentDef(oldComp, newComp) { + extend(oldComp, newComp); + for (const key in oldComp) if (key !== "__file" && !(key in newComp)) delete oldComp[key]; +} +function tryWrap(fn) { + return (id, arg) => { + try { + return fn(id, arg); + } catch (e) { + console.error(e); + console.warn(`[HMR] Something went wrong during Vue component hot-reload. Full reload required.`); + } + }; +} +var devtools$1; +var buffer = []; +var devtoolsNotInstalled = false; +function emit$1(event, ...args) { + if (devtools$1) devtools$1.emit(event, ...args); + else if (!devtoolsNotInstalled) buffer.push({ + event, + args + }); +} +function setDevtoolsHook$1(hook, target) { + var _a, _b; + devtools$1 = hook; + if (devtools$1) { + devtools$1.enabled = true; + buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args)); + buffer = []; + } else if (typeof window !== "undefined" && window.HTMLElement && !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))) { + (target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []).push((newHook) => { + setDevtoolsHook$1(newHook, target); + }); + setTimeout(() => { + if (!devtools$1) { + target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null; + devtoolsNotInstalled = true; + buffer = []; + } + }, 3e3); + } else { + devtoolsNotInstalled = true; + buffer = []; + } +} +function devtoolsInitApp(app, version) { + emit$1("app:init", app, version, { + Fragment, + Text, + Comment, + Static + }); +} +function devtoolsUnmountApp(app) { + emit$1("app:unmount", app); +} +var devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook("component:added"); +var devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated"); +var _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook("component:removed"); +var devtoolsComponentRemoved = (component) => { + if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && !devtools$1.cleanupBuffer(component)) _devtoolsComponentRemoved(component); +}; +// @__NO_SIDE_EFFECTS__ +function createDevtoolsComponentHook(hook) { + return (component) => { + emit$1(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : void 0, component); + }; +} +var devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:start"); +var devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:end"); +function createDevtoolsPerformanceHook(hook) { + return (component, type, time) => { + emit$1(hook, component.appContext.app, component.uid, component, type, time); + }; +} +function devtoolsComponentEmit(component, event, params) { + emit$1("component:emit", component.appContext.app, component, event, params); +} +var currentRenderingInstance = null; +var currentScopeId = null; +function setCurrentRenderingInstance(instance) { + const prev = currentRenderingInstance; + currentRenderingInstance = instance; + currentScopeId = instance && instance.type.__scopeId || null; + return prev; +} +function pushScopeId(id) { + currentScopeId = id; +} +function popScopeId() { + currentScopeId = null; +} +var withScopeId = (_id) => withCtx; +function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) { + if (!ctx) return fn; + if (fn._n) return fn; + const renderFnWithContext = (...args) => { + if (renderFnWithContext._d) setBlockTracking(-1); + const prevInstance = setCurrentRenderingInstance(ctx); + let res; + try { + res = fn(...args); + } finally { + setCurrentRenderingInstance(prevInstance); + if (renderFnWithContext._d) setBlockTracking(1); + } + devtoolsComponentUpdated(ctx); + return res; + }; + renderFnWithContext._n = true; + renderFnWithContext._c = true; + renderFnWithContext._d = true; + return renderFnWithContext; +} +function validateDirectiveName(name) { + if (isBuiltInDirective(name)) warn$1("Do not use built-in directive ids as custom directive id: " + name); +} +function withDirectives(vnode, directives) { + if (currentRenderingInstance === null) { + warn$1(`withDirectives can only be used inside render functions.`); + return vnode; + } + const instance = getComponentPublicInstance(currentRenderingInstance); + const bindings = vnode.dirs || (vnode.dirs = []); + for (let i = 0; i < directives.length; i++) { + let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i]; + if (dir) { + if (isFunction(dir)) dir = { + mounted: dir, + updated: dir + }; + if (dir.deep) traverse(value); + bindings.push({ + dir, + instance, + value, + oldValue: void 0, + arg, + modifiers + }); + } + } + return vnode; +} +function invokeDirectiveHook(vnode, prevVNode, instance, name) { + const bindings = vnode.dirs; + const oldBindings = prevVNode && prevVNode.dirs; + for (let i = 0; i < bindings.length; i++) { + const binding = bindings[i]; + if (oldBindings) binding.oldValue = oldBindings[i].value; + let hook = binding.dir[name]; + if (hook) { + pauseTracking(); + callWithAsyncErrorHandling(hook, instance, 8, [ + vnode.el, + binding, + vnode, + prevVNode + ]); + resetTracking(); + } + } +} +function provide(key, value) { + if (!currentInstance || currentInstance.isMounted) warn$1(`provide() can only be used inside setup().`); + if (currentInstance) { + let provides = currentInstance.provides; + const parentProvides = currentInstance.parent && currentInstance.parent.provides; + if (parentProvides === provides) provides = currentInstance.provides = Object.create(parentProvides); + provides[key] = value; + } +} +function inject(key, defaultValue, treatDefaultAsFactory = false) { + const instance = getCurrentInstance(); + if (instance || currentApp) { + let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0; + if (provides && key in provides) return provides[key]; + else if (arguments.length > 1) return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue; + else warn$1(`injection "${String(key)}" not found.`); + } else warn$1(`inject() can only be used inside setup() or functional components.`); +} +function hasInjectionContext() { + return !!(getCurrentInstance() || currentApp); +} +var ssrContextKey = /* @__PURE__ */ Symbol.for("v-scx"); +var useSSRContext = () => { + { + const ctx = inject(ssrContextKey); + if (!ctx) warn$1(`Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`); + return ctx; + } +}; +function watchEffect(effect, options) { + return doWatch(effect, null, options); +} +function watchPostEffect(effect, options) { + return doWatch(effect, null, extend({}, options, { flush: "post" })); +} +function watchSyncEffect(effect, options) { + return doWatch(effect, null, extend({}, options, { flush: "sync" })); +} +function watch(source, cb, options) { + if (!isFunction(cb)) warn$1(`\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`); + return doWatch(source, cb, options); +} +function doWatch(source, cb, options = EMPTY_OBJ) { + const { immediate, deep, flush, once } = options; + if (!cb) { + if (immediate !== void 0) warn$1(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`); + if (deep !== void 0) warn$1(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`); + if (once !== void 0) warn$1(`watch() "once" option is only respected when using the watch(source, callback, options?) signature.`); + } + const baseWatchOptions = extend({}, options); + baseWatchOptions.onWarn = warn$1; + const runsImmediately = cb && immediate || !cb && flush !== "post"; + let ssrCleanup; + if (isInSSRComponentSetup) { + if (flush === "sync") { + const ctx = useSSRContext(); + ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []); + } else if (!runsImmediately) { + const watchStopHandle = () => {}; + watchStopHandle.stop = NOOP; + watchStopHandle.resume = NOOP; + watchStopHandle.pause = NOOP; + return watchStopHandle; + } + } + const instance = currentInstance; + baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args); + let isPre = false; + if (flush === "post") baseWatchOptions.scheduler = (job) => { + queuePostRenderEffect(job, instance && instance.suspense); + }; + else if (flush !== "sync") { + isPre = true; + baseWatchOptions.scheduler = (job, isFirstRun) => { + if (isFirstRun) job(); + else queueJob(job); + }; + } + baseWatchOptions.augmentJob = (job) => { + if (cb) job.flags |= 4; + if (isPre) { + job.flags |= 2; + if (instance) { + job.id = instance.uid; + job.i = instance; + } + } + }; + const watchHandle = watch$1(source, cb, baseWatchOptions); + if (isInSSRComponentSetup) { + if (ssrCleanup) ssrCleanup.push(watchHandle); + else if (runsImmediately) watchHandle(); + } + return watchHandle; +} +function instanceWatch(source, value, options) { + const publicThis = this.proxy; + const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis); + let cb; + if (isFunction(value)) cb = value; + else { + cb = value.handler; + options = value; + } + const reset = setCurrentInstance(this); + const res = doWatch(getter, cb.bind(publicThis), options); + reset(); + return res; +} +function createPathGetter(ctx, path) { + const segments = path.split("."); + return () => { + let cur = ctx; + for (let i = 0; i < segments.length && cur; i++) cur = cur[segments[i]]; + return cur; + }; +} +var pendingMounts = /* @__PURE__ */ new WeakMap(); +var TeleportEndKey = /* @__PURE__ */ Symbol("_vte"); +var isTeleport = (type) => type.__isTeleport; +var isTeleportDisabled = (props) => props && (props.disabled || props.disabled === ""); +var isTeleportDeferred = (props) => props && (props.defer || props.defer === ""); +var isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement; +var isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement; +var resolveTarget = (props, select) => { + const targetSelector = props && props.to; + if (isString(targetSelector)) if (!select) { + warn$1(`Current renderer does not support string target for Teleports. (missing querySelector renderer option)`); + return null; + } else { + const target = select(targetSelector); + if (!target && !isTeleportDisabled(props)) warn$1(`Failed to locate Teleport target with selector "${targetSelector}". Note the target element must exist before the component is mounted - i.e. the target cannot be rendered by the component itself, and ideally should be outside of the entire Vue component tree.`); + return target; + } + else { + if (!targetSelector && !isTeleportDisabled(props)) warn$1(`Invalid Teleport target: ${targetSelector}`); + return targetSelector; + } +}; +var TeleportImpl = { + name: "Teleport", + __isTeleport: true, + process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) { + const { mc: mountChildren, pc: patchChildren, pbc: patchBlockChildren, o: { insert, querySelector, createText, createComment, parentNode } } = internals; + const disabled = isTeleportDisabled(n2.props); + let { dynamicChildren } = n2; + if (isHmrUpdating) { + optimized = false; + dynamicChildren = null; + } + const mount = (vnode, container2, anchor2) => { + if (vnode.shapeFlag & 16) mountChildren(vnode.children, container2, anchor2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized); + }; + const mountToTarget = (vnode = n2) => { + const disabled2 = isTeleportDisabled(vnode.props); + const target = vnode.target = resolveTarget(vnode.props, querySelector); + const targetAnchor = prepareAnchor(target, vnode, createText, insert); + if (target) { + if (namespace !== "svg" && isTargetSVG(target)) namespace = "svg"; + else if (namespace !== "mathml" && isTargetMathML(target)) namespace = "mathml"; + if (parentComponent && parentComponent.isCE) (parentComponent.ce._teleportTargets || (parentComponent.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target); + if (!disabled2) { + mount(vnode, target, targetAnchor); + updateCssVars(vnode, false); + } + } else if (!disabled2) warn$1("Invalid Teleport target on mount:", target, `(${typeof target})`); + }; + const queuePendingMount = (vnode) => { + const mountJob = () => { + if (pendingMounts.get(vnode) !== mountJob) return; + pendingMounts.delete(vnode); + if (isTeleportDisabled(vnode.props)) { + const mountContainer = parentNode(vnode.el) || container; + mount(vnode, mountContainer, vnode.anchor); + updateCssVars(vnode, true); + } + mountToTarget(vnode); + }; + pendingMounts.set(vnode, mountJob); + queuePostRenderEffect(mountJob, parentSuspense); + }; + if (n1 == null) { + const placeholder = n2.el = createComment("teleport start"); + const mainAnchor = n2.anchor = createComment("teleport end"); + insert(placeholder, container, anchor); + insert(mainAnchor, container, anchor); + if (isTeleportDeferred(n2.props) || parentSuspense && parentSuspense.pendingBranch) { + queuePendingMount(n2); + return; + } + if (disabled) { + mount(n2, container, mainAnchor); + updateCssVars(n2, true); + } + mountToTarget(); + } else { + n2.el = n1.el; + const mainAnchor = n2.anchor = n1.anchor; + const pendingMount = pendingMounts.get(n1); + if (pendingMount) { + pendingMount.flags |= 8; + pendingMounts.delete(n1); + queuePendingMount(n2); + return; + } + n2.targetStart = n1.targetStart; + const target = n2.target = n1.target; + const targetAnchor = n2.targetAnchor = n1.targetAnchor; + const wasDisabled = isTeleportDisabled(n1.props); + const currentContainer = wasDisabled ? container : target; + const currentAnchor = wasDisabled ? mainAnchor : targetAnchor; + if (namespace === "svg" || isTargetSVG(target)) namespace = "svg"; + else if (namespace === "mathml" || isTargetMathML(target)) namespace = "mathml"; + if (dynamicChildren) { + patchBlockChildren(n1.dynamicChildren, dynamicChildren, currentContainer, parentComponent, parentSuspense, namespace, slotScopeIds); + traverseStaticChildren(n1, n2, false); + } else if (!optimized) patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, false); + if (disabled) { + if (!wasDisabled) moveTeleport(n2, container, mainAnchor, internals, 1); + else if (n2.props && n1.props && n2.props.to !== n1.props.to) n2.props.to = n1.props.to; + } else if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) { + const nextTarget = resolveTarget(n2.props, querySelector); + if (nextTarget) { + n2.target = nextTarget; + moveTeleport(n2, nextTarget, null, internals, 0); + } else warn$1("Invalid Teleport target on update:", target, `(${typeof target})`); + } else if (wasDisabled) moveTeleport(n2, target, targetAnchor, internals, 1); + updateCssVars(n2, disabled); + } + }, + remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) { + const { shapeFlag, children, anchor, targetStart, targetAnchor, target, props } = vnode; + const disabled = isTeleportDisabled(props); + const shouldRemove = doRemove || !disabled; + const pendingMount = pendingMounts.get(vnode); + if (pendingMount) { + pendingMount.flags |= 8; + pendingMounts.delete(vnode); + } + if (target) { + hostRemove(targetStart); + hostRemove(targetAnchor); + } + doRemove && hostRemove(anchor); + if (!pendingMount && (disabled || target) && shapeFlag & 16) for (let i = 0; i < children.length; i++) { + const child = children[i]; + unmount(child, parentComponent, parentSuspense, shouldRemove, !!child.dynamicChildren); + } + }, + move: moveTeleport, + hydrate: hydrateTeleport +}; +function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) { + if (moveType === 0) insert(vnode.targetAnchor, container, parentAnchor); + const { el, anchor, shapeFlag, children, props } = vnode; + const isReorder = moveType === 2; + if (isReorder) insert(el, container, parentAnchor); + if (!pendingMounts.has(vnode) && (!isReorder || isTeleportDisabled(props))) { + if (shapeFlag & 16) for (let i = 0; i < children.length; i++) move(children[i], container, parentAnchor, 2); + } + if (isReorder) insert(anchor, container, parentAnchor); +} +function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, { o: { nextSibling, parentNode, querySelector, insert, createText } }, hydrateChildren) { + function hydrateAnchor(target2, targetNode) { + let targetAnchor = targetNode; + while (targetAnchor) { + if (targetAnchor && targetAnchor.nodeType === 8) { + if (targetAnchor.data === "teleport start anchor") vnode.targetStart = targetAnchor; + else if (targetAnchor.data === "teleport anchor") { + vnode.targetAnchor = targetAnchor; + target2._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor); + break; + } + } + targetAnchor = nextSibling(targetAnchor); + } + } + function hydrateDisabledTeleport(node2, vnode2) { + vnode2.anchor = hydrateChildren(nextSibling(node2), vnode2, parentNode(node2), parentComponent, parentSuspense, slotScopeIds, optimized); + } + const target = vnode.target = resolveTarget(vnode.props, querySelector); + const disabled = isTeleportDisabled(vnode.props); + if (target) { + const targetNode = target._lpa || target.firstChild; + if (vnode.shapeFlag & 16) if (disabled) { + hydrateDisabledTeleport(node, vnode); + hydrateAnchor(target, targetNode); + if (!vnode.targetAnchor) prepareAnchor(target, vnode, createText, insert, parentNode(node) === target ? node : null); + } else { + vnode.anchor = nextSibling(node); + hydrateAnchor(target, targetNode); + if (!vnode.targetAnchor) prepareAnchor(target, vnode, createText, insert); + hydrateChildren(targetNode && nextSibling(targetNode), vnode, target, parentComponent, parentSuspense, slotScopeIds, optimized); + } + updateCssVars(vnode, disabled); + } else if (disabled) { + if (vnode.shapeFlag & 16) { + hydrateDisabledTeleport(node, vnode); + vnode.targetStart = node; + vnode.targetAnchor = nextSibling(node); + } + } + return vnode.anchor && nextSibling(vnode.anchor); +} +var Teleport = TeleportImpl; +function updateCssVars(vnode, isDisabled) { + const ctx = vnode.ctx; + if (ctx && ctx.ut) { + let node, anchor; + if (isDisabled) { + node = vnode.el; + anchor = vnode.anchor; + } else { + node = vnode.targetStart; + anchor = vnode.targetAnchor; + } + while (node && node !== anchor) { + if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid); + node = node.nextSibling; + } + ctx.ut(); + } +} +function prepareAnchor(target, vnode, createText, insert, anchor = null) { + const targetStart = vnode.targetStart = createText(""); + const targetAnchor = vnode.targetAnchor = createText(""); + targetStart[TeleportEndKey] = targetAnchor; + if (target) { + insert(targetStart, target, anchor); + insert(targetAnchor, target, anchor); + } + return targetAnchor; +} +var leaveCbKey = /* @__PURE__ */ Symbol("_leaveCb"); +var enterCbKey$1 = /* @__PURE__ */ Symbol("_enterCb"); +function useTransitionState() { + const state = { + isMounted: false, + isLeaving: false, + isUnmounting: false, + leavingVNodes: /* @__PURE__ */ new Map() + }; + onMounted(() => { + state.isMounted = true; + }); + onBeforeUnmount(() => { + state.isUnmounting = true; + }); + return state; +} +var TransitionHookValidator = [Function, Array]; +var BaseTransitionPropsValidators = { + mode: String, + appear: Boolean, + persisted: Boolean, + onBeforeEnter: TransitionHookValidator, + onEnter: TransitionHookValidator, + onAfterEnter: TransitionHookValidator, + onEnterCancelled: TransitionHookValidator, + onBeforeLeave: TransitionHookValidator, + onLeave: TransitionHookValidator, + onAfterLeave: TransitionHookValidator, + onLeaveCancelled: TransitionHookValidator, + onBeforeAppear: TransitionHookValidator, + onAppear: TransitionHookValidator, + onAfterAppear: TransitionHookValidator, + onAppearCancelled: TransitionHookValidator +}; +var recursiveGetSubtree = (instance) => { + const subTree = instance.subTree; + return subTree.component ? recursiveGetSubtree(subTree.component) : subTree; +}; +var BaseTransitionImpl = { + name: `BaseTransition`, + props: BaseTransitionPropsValidators, + setup(props, { slots }) { + const instance = getCurrentInstance(); + const state = useTransitionState(); + return () => { + const children = slots.default && getTransitionRawChildren(slots.default(), true); + const child = children && children.length ? findNonCommentChild(children) : instance.subTree ? createCommentVNode() : void 0; + if (!child) return; + const rawProps = /* @__PURE__ */ toRaw(props); + const { mode } = rawProps; + if (mode && mode !== "in-out" && mode !== "out-in" && mode !== "default") warn$1(`invalid mode: ${mode}`); + if (state.isLeaving) return emptyPlaceholder(child); + const innerChild = getInnerChild$1(child); + if (!innerChild) return emptyPlaceholder(child); + let enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance, (hooks) => enterHooks = hooks); + if (innerChild.type !== Comment) setTransitionHooks(innerChild, enterHooks); + let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree); + if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(oldInnerChild, innerChild) && recursiveGetSubtree(instance).type !== Comment) { + let leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance); + setTransitionHooks(oldInnerChild, leavingHooks); + if (mode === "out-in" && innerChild.type !== Comment) { + state.isLeaving = true; + leavingHooks.afterLeave = () => { + state.isLeaving = false; + if (!(instance.job.flags & 8)) instance.update(); + delete leavingHooks.afterLeave; + oldInnerChild = void 0; + }; + return emptyPlaceholder(child); + } else if (mode === "in-out" && innerChild.type !== Comment) leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => { + const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild); + leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild; + el[leaveCbKey] = () => { + earlyRemove(); + el[leaveCbKey] = void 0; + delete enterHooks.delayedLeave; + oldInnerChild = void 0; + }; + enterHooks.delayedLeave = () => { + delayedLeave(); + delete enterHooks.delayedLeave; + oldInnerChild = void 0; + }; + }; + else oldInnerChild = void 0; + } else if (oldInnerChild) oldInnerChild = void 0; + return child; + }; + } +}; +function findNonCommentChild(children) { + let child = children[0]; + if (children.length > 1) { + let hasFound = false; + for (const c of children) if (c.type !== Comment) { + if (hasFound) { + warn$1(" can only be used on a single element or component. Use for lists."); + break; + } + child = c; + hasFound = true; + } + } + return child; +} +var BaseTransition = BaseTransitionImpl; +function getLeavingNodesForType(state, vnode) { + const { leavingVNodes } = state; + let leavingVNodesCache = leavingVNodes.get(vnode.type); + if (!leavingVNodesCache) { + leavingVNodesCache = /* @__PURE__ */ Object.create(null); + leavingVNodes.set(vnode.type, leavingVNodesCache); + } + return leavingVNodesCache; +} +function resolveTransitionHooks(vnode, props, state, instance, postClone) { + const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props; + const key = String(vnode.key); + const leavingVNodesCache = getLeavingNodesForType(state, vnode); + const callHook = (hook, args) => { + hook && callWithAsyncErrorHandling(hook, instance, 9, args); + }; + const callAsyncHook = (hook, args) => { + const done = args[1]; + callHook(hook, args); + if (isArray(hook)) { + if (hook.every((hook2) => hook2.length <= 1)) done(); + } else if (hook.length <= 1) done(); + }; + const hooks = { + mode, + persisted, + beforeEnter(el) { + let hook = onBeforeEnter; + if (!state.isMounted) if (appear) hook = onBeforeAppear || onBeforeEnter; + else return; + if (el[leaveCbKey]) el[leaveCbKey](true); + const leavingVNode = leavingVNodesCache[key]; + if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) leavingVNode.el[leaveCbKey](); + callHook(hook, [el]); + }, + enter(el) { + if (!isHmrUpdating && leavingVNodesCache[key] === vnode) return; + let hook = onEnter; + let afterHook = onAfterEnter; + let cancelHook = onEnterCancelled; + if (!state.isMounted) if (appear) { + hook = onAppear || onEnter; + afterHook = onAfterAppear || onAfterEnter; + cancelHook = onAppearCancelled || onEnterCancelled; + } else return; + let called = false; + el[enterCbKey$1] = (cancelled) => { + if (called) return; + called = true; + if (cancelled) callHook(cancelHook, [el]); + else callHook(afterHook, [el]); + if (hooks.delayedLeave) hooks.delayedLeave(); + el[enterCbKey$1] = void 0; + }; + const done = el[enterCbKey$1].bind(null, false); + if (hook) callAsyncHook(hook, [el, done]); + else done(); + }, + leave(el, remove) { + const key2 = String(vnode.key); + if (el[enterCbKey$1]) el[enterCbKey$1](true); + if (state.isUnmounting) return remove(); + callHook(onBeforeLeave, [el]); + let called = false; + el[leaveCbKey] = (cancelled) => { + if (called) return; + called = true; + remove(); + if (cancelled) callHook(onLeaveCancelled, [el]); + else callHook(onAfterLeave, [el]); + el[leaveCbKey] = void 0; + if (leavingVNodesCache[key2] === vnode) delete leavingVNodesCache[key2]; + }; + const done = el[leaveCbKey].bind(null, false); + leavingVNodesCache[key2] = vnode; + if (onLeave) callAsyncHook(onLeave, [el, done]); + else done(); + }, + clone(vnode2) { + const hooks2 = resolveTransitionHooks(vnode2, props, state, instance, postClone); + if (postClone) postClone(hooks2); + return hooks2; + } + }; + return hooks; +} +function emptyPlaceholder(vnode) { + if (isKeepAlive(vnode)) { + vnode = cloneVNode(vnode); + vnode.children = null; + return vnode; + } +} +function getInnerChild$1(vnode) { + if (!isKeepAlive(vnode)) { + if (isTeleport(vnode.type) && vnode.children) return findNonCommentChild(vnode.children); + return vnode; + } + if (vnode.component) return vnode.component.subTree; + const { shapeFlag, children } = vnode; + if (children) { + if (shapeFlag & 16) return children[0]; + if (shapeFlag & 32 && isFunction(children.default)) return children.default(); + } +} +function setTransitionHooks(vnode, hooks) { + if (vnode.shapeFlag & 6 && vnode.component) { + vnode.transition = hooks; + setTransitionHooks(vnode.component.subTree, hooks); + } else if (vnode.shapeFlag & 128) { + vnode.ssContent.transition = hooks.clone(vnode.ssContent); + vnode.ssFallback.transition = hooks.clone(vnode.ssFallback); + } else vnode.transition = hooks; +} +function getTransitionRawChildren(children, keepComment = false, parentKey) { + let ret = []; + let keyedFragmentCount = 0; + for (let i = 0; i < children.length; i++) { + let child = children[i]; + const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i); + if (child.type === Fragment) { + if (child.patchFlag & 128) keyedFragmentCount++; + ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key)); + } else if (keepComment || child.type !== Comment) ret.push(key != null ? cloneVNode(child, { key }) : child); + } + if (keyedFragmentCount > 1) for (let i = 0; i < ret.length; i++) ret[i].patchFlag = -2; + return ret; +} +// @__NO_SIDE_EFFECTS__ +function defineComponent(options, extraOptions) { + return isFunction(options) ? /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))() : options; +} +function useId() { + const i = getCurrentInstance(); + if (i) return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++; + else warn$1(`useId() is called when there is no active component instance to be associated with.`); + return ""; +} +function markAsyncBoundary(instance) { + instance.ids = [ + instance.ids[0] + instance.ids[2]++ + "-", + 0, + 0 + ]; +} +var knownTemplateRefs = /* @__PURE__ */ new WeakSet(); +function useTemplateRef(key) { + const i = getCurrentInstance(); + const r = /* @__PURE__ */ shallowRef(null); + if (i) { + const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs; + if (isTemplateRefKey(refs, key)) warn$1(`useTemplateRef('${key}') already exists.`); + else Object.defineProperty(refs, key, { + enumerable: true, + get: () => r.value, + set: (val) => r.value = val + }); + } else warn$1(`useTemplateRef() is called when there is no active component instance to be associated with.`); + const ret = /* @__PURE__ */ readonly(r); + knownTemplateRefs.add(ret); + return ret; +} +function isTemplateRefKey(refs, key) { + let desc; + return !!((desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable); +} +var pendingSetRefMap = /* @__PURE__ */ new WeakMap(); +function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) { + if (isArray(rawRef)) { + rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount)); + return; + } + if (isAsyncWrapper(vnode) && !isUnmount) { + if (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) setRef(rawRef, oldRawRef, parentSuspense, vnode.component.subTree); + return; + } + const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el; + const value = isUnmount ? null : refValue; + const { i: owner, r: ref } = rawRef; + if (!owner) { + warn$1(`Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.`); + return; + } + const oldRef = oldRawRef && oldRawRef.r; + const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs; + const setupState = owner.setupState; + const rawSetupState = /* @__PURE__ */ toRaw(setupState); + const canSetSetupRef = setupState === EMPTY_OBJ ? NO : (key) => { + if (hasOwn(rawSetupState, key) && !/* @__PURE__ */ isRef(rawSetupState[key])) warn$1(`Template ref "${key}" used on a non-ref value. It will not work in the production build.`); + if (knownTemplateRefs.has(rawSetupState[key])) return false; + if (isTemplateRefKey(refs, key)) return false; + return hasOwn(rawSetupState, key); + }; + const canSetRef = (ref2, key) => { + if (knownTemplateRefs.has(ref2)) return false; + if (key && isTemplateRefKey(refs, key)) return false; + return true; + }; + if (oldRef != null && oldRef !== ref) { + invalidatePendingSetRef(oldRawRef); + if (isString(oldRef)) { + refs[oldRef] = null; + if (canSetSetupRef(oldRef)) setupState[oldRef] = null; + } else if (/* @__PURE__ */ isRef(oldRef)) { + const oldRawRefAtom = oldRawRef; + if (canSetRef(oldRef, oldRawRefAtom.k)) oldRef.value = null; + if (oldRawRefAtom.k) refs[oldRawRefAtom.k] = null; + } + } + if (isFunction(ref)) { + pauseTracking(); + try { + callWithErrorHandling(ref, owner, 12, [value, refs]); + } finally { + resetTracking(); + } + } else { + const _isString = isString(ref); + const _isRef = /* @__PURE__ */ isRef(ref); + if (_isString || _isRef) { + const doSet = () => { + if (rawRef.f) { + const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : canSetRef(ref) || !rawRef.k ? ref.value : refs[rawRef.k]; + if (isUnmount) isArray(existing) && remove(existing, refValue); + else if (!isArray(existing)) if (_isString) { + refs[ref] = [refValue]; + if (canSetSetupRef(ref)) setupState[ref] = refs[ref]; + } else { + const newVal = [refValue]; + if (canSetRef(ref, rawRef.k)) ref.value = newVal; + if (rawRef.k) refs[rawRef.k] = newVal; + } + else if (!existing.includes(refValue)) existing.push(refValue); + } else if (_isString) { + refs[ref] = value; + if (canSetSetupRef(ref)) setupState[ref] = value; + } else if (_isRef) { + if (canSetRef(ref, rawRef.k)) ref.value = value; + if (rawRef.k) refs[rawRef.k] = value; + } else warn$1("Invalid template ref type:", ref, `(${typeof ref})`); + }; + if (value) { + const job = () => { + doSet(); + pendingSetRefMap.delete(rawRef); + }; + job.id = -1; + pendingSetRefMap.set(rawRef, job); + queuePostRenderEffect(job, parentSuspense); + } else { + invalidatePendingSetRef(rawRef); + doSet(); + } + } else warn$1("Invalid template ref type:", ref, `(${typeof ref})`); + } +} +function invalidatePendingSetRef(rawRef) { + const pendingSetRef = pendingSetRefMap.get(rawRef); + if (pendingSetRef) { + pendingSetRef.flags |= 8; + pendingSetRefMap.delete(rawRef); + } +} +var hasLoggedMismatchError = false; +var logMismatchError = () => { + if (hasLoggedMismatchError) return; + console.error("Hydration completed but contains mismatches."); + hasLoggedMismatchError = true; +}; +var isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject"; +var isMathMLContainer = (container) => container.namespaceURI.includes("MathML"); +var getContainerType = (container) => { + if (container.nodeType !== 1) return void 0; + if (isSVGContainer(container)) return "svg"; + if (isMathMLContainer(container)) return "mathml"; +}; +var isComment = (node) => node.nodeType === 8; +function createHydrationFunctions(rendererInternals) { + const { mt: mountComponent, p: patch, o: { patchProp, createText, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals; + const hydrate = (vnode, container) => { + if (!container.hasChildNodes()) { + warn$1(`Attempting to hydrate existing markup but container is empty. Performing full mount instead.`); + patch(null, vnode, container); + flushPostFlushCbs(); + container._vnode = vnode; + return; + } + hydrateNode(container.firstChild, vnode, null, null, null); + flushPostFlushCbs(); + container._vnode = vnode; + }; + const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => { + optimized = optimized || !!vnode.dynamicChildren; + const isFragmentStart = isComment(node) && node.data === "["; + const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart); + const { type, ref, shapeFlag, patchFlag } = vnode; + let domType = node.nodeType; + vnode.el = node; + def(node, "__vnode", vnode, true); + def(node, "__vueParentComponent", parentComponent, true); + if (patchFlag === -2) { + optimized = false; + vnode.dynamicChildren = null; + } + let nextNode = null; + switch (type) { + case Text: + if (domType !== 3) if (vnode.children === "") { + insert(vnode.el = createText(""), parentNode(node), node); + nextNode = node; + } else nextNode = onMismatch(); + else { + if (node.data !== vnode.children) { + warn$1(`Hydration text mismatch in`, node.parentNode, ` + - rendered on server: ${JSON.stringify(node.data)} + - expected on client: ${JSON.stringify(vnode.children)}`); + logMismatchError(); + node.data = vnode.children; + } + nextNode = nextSibling(node); + } + break; + case Comment: + if (isTemplateNode(node)) { + nextNode = nextSibling(node); + replaceNode(vnode.el = node.content.firstChild, node, parentComponent); + } else if (domType !== 8 || isFragmentStart) nextNode = onMismatch(); + else nextNode = nextSibling(node); + break; + case Static: + if (isFragmentStart) { + node = nextSibling(node); + domType = node.nodeType; + } + if (domType === 1 || domType === 3) { + nextNode = node; + const needToAdoptContent = !vnode.children.length; + for (let i = 0; i < vnode.staticCount; i++) { + if (needToAdoptContent) vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data; + if (i === vnode.staticCount - 1) vnode.anchor = nextNode; + nextNode = nextSibling(nextNode); + } + return isFragmentStart ? nextSibling(nextNode) : nextNode; + } else onMismatch(); + break; + case Fragment: + if (!isFragmentStart) nextNode = onMismatch(); + else nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + break; + default: if (shapeFlag & 1) if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) nextNode = onMismatch(); + else nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + else if (shapeFlag & 6) { + vnode.slotScopeIds = slotScopeIds; + const container = parentNode(node); + if (isFragmentStart) nextNode = locateClosingAnchor(node); + else if (isComment(node) && node.data === "teleport start") nextNode = locateClosingAnchor(node, node.data, "teleport end"); + else nextNode = nextSibling(node); + mountComponent(vnode, container, null, parentComponent, parentSuspense, getContainerType(container), optimized); + if (isAsyncWrapper(vnode) && !vnode.type.__asyncResolved) { + let subTree; + if (isFragmentStart) { + subTree = createVNode(Fragment); + subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild; + } else subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div"); + subTree.el = node; + vnode.component.subTree = subTree; + } + } else if (shapeFlag & 64) if (domType !== 8) nextNode = onMismatch(); + else nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren); + else if (shapeFlag & 128) nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, getContainerType(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode); + else warn$1("Invalid HostVNode type:", type, `(${typeof type})`); + } + if (ref != null) setRef(ref, null, parentSuspense, vnode); + return nextNode; + }; + const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { + optimized = optimized || !!vnode.dynamicChildren; + const { type, dynamicProps, props, patchFlag, shapeFlag, dirs, transition } = vnode; + const forcePatch = type === "input" || type === "option"; + { + if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "created"); + let needCallTransitionHooks = false; + if (isTemplateNode(el)) { + needCallTransitionHooks = needTransition(null, transition) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear; + const content = el.content.firstChild; + if (needCallTransitionHooks) { + const cls = content.getAttribute("class"); + if (cls) content.$cls = cls; + transition.beforeEnter(content); + } + replaceNode(content, el, parentComponent); + vnode.el = el = content; + } + if (shapeFlag & 16 && !(props && (props.innerHTML || props.textContent))) { + let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized); + if (next && !isMismatchAllowed(el, 1)) { + warn$1(`Hydration children mismatch on`, el, ` +Server rendered element contains more child nodes than client vdom.`); + logMismatchError(); + } + while (next) { + const cur = next; + next = next.nextSibling; + remove(cur); + } + } else if (shapeFlag & 8) { + let clientText = vnode.children; + if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) clientText = clientText.slice(1); + const { textContent } = el; + if (textContent !== clientText && textContent !== clientText.replace(/\r\n|\r/g, "\n")) { + if (!isMismatchAllowed(el, 0)) { + warn$1(`Hydration text content mismatch on`, el, ` + - rendered on server: ${textContent} + - expected on client: ${clientText}`); + logMismatchError(); + } + el.textContent = vnode.children; + } + } + if (props) { + const isCustomElement = el.tagName.includes("-"); + for (const key in props) { + if (!(dirs && dirs.some((d) => d.dir.created)) && propHasMismatch(el, key, props[key], vnode, parentComponent)) logMismatchError(); + if (forcePatch && (key.endsWith("value") || key === "indeterminate") || isOn(key) && !isReservedProp(key) || key[0] === "." || isCustomElement && !isReservedProp(key) || dynamicProps && dynamicProps.includes(key)) patchProp(el, key, null, props[key], void 0, parentComponent); + } + } + let vnodeHooks; + if (vnodeHooks = props && props.onVnodeBeforeMount) invokeVNodeHook(vnodeHooks, parentComponent, vnode); + if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "beforeMount"); + if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) queueEffectWithSuspense(() => { + vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode); + needCallTransitionHooks && transition.enter(el); + dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted"); + }, parentSuspense); + } + return el.nextSibling; + }; + const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => { + optimized = optimized || !!parentVNode.dynamicChildren; + const children = parentVNode.children; + const l = children.length; + let hasCheckedMismatch = false; + for (let i = 0; i < l; i++) { + const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]); + const isText = vnode.type === Text; + if (node) { + if (isText && !optimized) { + if (i + 1 < l && normalizeVNode(children[i + 1]).type === Text) { + insert(createText(node.data.slice(vnode.children.length)), container, nextSibling(node)); + node.data = vnode.children; + } + } + node = hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } else if (isText && !vnode.children) insert(vnode.el = createText(""), container); + else { + if (!hasCheckedMismatch) { + hasCheckedMismatch = true; + if (!isMismatchAllowed(container, 1)) { + warn$1(`Hydration children mismatch on`, container, ` +Server rendered element contains fewer child nodes than client vdom.`); + logMismatchError(); + } + } + patch(null, vnode, container, null, parentComponent, parentSuspense, getContainerType(container), slotScopeIds); + } + } + return node; + }; + const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { + const { slotScopeIds: fragmentSlotScopeIds } = vnode; + if (fragmentSlotScopeIds) slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds; + const container = parentNode(node); + const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized); + if (next && isComment(next) && next.data === "]") return nextSibling(vnode.anchor = next); + else { + logMismatchError(); + insert(vnode.anchor = createComment(`]`), container, next); + return next; + } + }; + const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => { + if (!isNodeMismatchAllowed(node, vnode)) { + warn$1(`Hydration node mismatch: +- rendered on server:`, node, node.nodeType === 3 ? `(text)` : isComment(node) && node.data === "[" ? `(start of fragment)` : ``, ` +- expected on client:`, vnode.type); + logMismatchError(); + } + vnode.el = null; + if (isFragment) { + const end = locateClosingAnchor(node); + while (true) { + const next2 = nextSibling(node); + if (next2 && next2 !== end) remove(next2); + else break; + } + } + const next = nextSibling(node); + const container = parentNode(node); + remove(node); + patch(null, vnode, container, next, parentComponent, parentSuspense, getContainerType(container), slotScopeIds); + if (parentComponent) { + parentComponent.vnode.el = vnode.el; + updateHOCHostEl(parentComponent, vnode.el); + } + return next; + }; + const locateClosingAnchor = (node, open = "[", close = "]") => { + let match = 0; + while (node) { + node = nextSibling(node); + if (node && isComment(node)) { + if (node.data === open) match++; + if (node.data === close) if (match === 0) return nextSibling(node); + else match--; + } + } + return node; + }; + const replaceNode = (newNode, oldNode, parentComponent) => { + const parentNode2 = oldNode.parentNode; + if (parentNode2) parentNode2.replaceChild(newNode, oldNode); + let parent = parentComponent; + while (parent) { + if (parent.vnode.el === oldNode) parent.vnode.el = parent.subTree.el = newNode; + parent = parent.parent; + } + }; + const isTemplateNode = (node) => { + return node.nodeType === 1 && node.tagName === "TEMPLATE"; + }; + return [hydrate, hydrateNode]; +} +function propHasMismatch(el, key, clientValue, vnode, instance) { + let mismatchType; + let mismatchKey; + let actual; + let expected; + if (key === "class") { + if (el.$cls) { + actual = el.$cls; + delete el.$cls; + } else actual = el.getAttribute("class"); + expected = normalizeClass(clientValue); + if (!isSetEqual(toClassSet(actual || ""), toClassSet(expected))) { + mismatchType = 2; + mismatchKey = `class`; + } + } else if (key === "style") { + actual = el.getAttribute("style") || ""; + expected = isString(clientValue) ? clientValue : stringifyStyle(normalizeStyle(clientValue)); + const actualMap = toStyleMap(actual); + const expectedMap = toStyleMap(expected); + if (vnode.dirs) { + for (const { dir, value } of vnode.dirs) if (dir.name === "show" && !value) expectedMap.set("display", "none"); + } + if (instance) resolveCssVars(instance, vnode, expectedMap); + if (!isMapEqual(actualMap, expectedMap)) { + mismatchType = 3; + mismatchKey = "style"; + } + } else if (el instanceof SVGElement && isKnownSvgAttr(key) || el instanceof HTMLElement && (isBooleanAttr(key) || isKnownHtmlAttr(key))) { + if (isBooleanAttr(key)) { + actual = el.hasAttribute(key); + expected = includeBooleanAttr(clientValue); + } else if (clientValue == null) { + actual = el.hasAttribute(key); + expected = false; + } else { + if (el.hasAttribute(key)) actual = el.getAttribute(key); + else if (key === "value" && el.tagName === "TEXTAREA") actual = el.value; + else actual = false; + expected = isRenderableAttrValue(clientValue) ? String(clientValue) : false; + } + if (actual !== expected) { + mismatchType = 4; + mismatchKey = key; + } + } + if (mismatchType != null && !isMismatchAllowed(el, mismatchType)) { + const format = (v) => v === false ? `(not rendered)` : `${mismatchKey}="${v}"`; + warn$1(`Hydration ${MismatchTypeString[mismatchType]} mismatch on`, el, ` + - rendered on server: ${format(actual)} + - expected on client: ${format(expected)} + Note: this mismatch is check-only. The DOM will not be rectified in production due to performance overhead. + You should fix the source of the mismatch.`); + return true; + } + return false; +} +function toClassSet(str) { + return new Set(str.trim().split(/\s+/)); +} +function isSetEqual(a, b) { + if (a.size !== b.size) return false; + for (const s of a) if (!b.has(s)) return false; + return true; +} +function toStyleMap(str) { + const styleMap = /* @__PURE__ */ new Map(); + for (const item of str.split(";")) { + let [key, value] = item.split(":"); + key = key.trim(); + value = value && value.trim(); + if (key && value) styleMap.set(key, value); + } + return styleMap; +} +function isMapEqual(a, b) { + if (a.size !== b.size) return false; + for (const [key, value] of a) if (value !== b.get(key)) return false; + return true; +} +function resolveCssVars(instance, vnode, expectedMap) { + const root = instance.subTree; + if (instance.getCssVars && (vnode === root || root && root.type === Fragment && root.children.includes(vnode))) { + const cssVars = instance.getCssVars(); + for (const key in cssVars) { + const value = normalizeCssVarValue(cssVars[key]); + expectedMap.set(`--${getEscapedCssVarName(key, false)}`, value); + } + } + if (vnode === root && instance.parent) resolveCssVars(instance.parent, instance.vnode, expectedMap); +} +var allowMismatchAttr = "data-allow-mismatch"; +var MismatchTypeString = { + [0]: "text", + [1]: "children", + [2]: "class", + [3]: "style", + [4]: "attribute" +}; +function isMismatchAllowed(el, allowedType) { + if (allowedType === 0 || allowedType === 1) while (el && !el.hasAttribute(allowMismatchAttr)) el = el.parentElement; + return isMismatchAllowedByAttr(el && el.getAttribute(allowMismatchAttr), allowedType); +} +function isMismatchAllowedByAttr(allowedAttr, allowedType) { + if (allowedAttr == null) return false; + else if (allowedAttr === "") return true; + else { + const list = allowedAttr.split(","); + if (allowedType === 0 && list.includes("children")) return true; + return list.includes(MismatchTypeString[allowedType]); + } +} +function isNodeMismatchAllowed(node, vnode) { + return isMismatchAllowed(node.parentElement, 1) || isMismatchAllowedByNode(node) || isMismatchAllowedByVNode(vnode); +} +function isMismatchAllowedByNode(node) { + return node.nodeType === 1 && isMismatchAllowedByAttr(node.getAttribute(allowMismatchAttr), 1); +} +function isMismatchAllowedByVNode({ props }) { + const allowedAttr = props && props[allowMismatchAttr]; + return typeof allowedAttr === "string" && isMismatchAllowedByAttr(allowedAttr, 1); +} +var requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1)); +var cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id)); +var hydrateOnIdle = (timeout = 1e4) => (hydrate) => { + const id = requestIdleCallback(hydrate, { timeout }); + return () => cancelIdleCallback(id); +}; +function elementIsVisibleInViewport(el) { + const { top, left, bottom, right } = el.getBoundingClientRect(); + const { innerHeight, innerWidth } = window; + return (top > 0 && top < innerHeight || bottom > 0 && bottom < innerHeight) && (left > 0 && left < innerWidth || right > 0 && right < innerWidth); +} +var hydrateOnVisible = (opts) => (hydrate, forEach) => { + const ob = new IntersectionObserver((entries) => { + for (const e of entries) { + if (!e.isIntersecting) continue; + ob.disconnect(); + hydrate(); + break; + } + }, opts); + forEach((el) => { + if (!(el instanceof Element)) return; + if (elementIsVisibleInViewport(el)) { + hydrate(); + ob.disconnect(); + return false; + } + ob.observe(el); + }); + return () => ob.disconnect(); +}; +var hydrateOnMediaQuery = (query) => (hydrate) => { + if (query) { + const mql = matchMedia(query); + if (mql.matches) hydrate(); + else { + mql.addEventListener("change", hydrate, { once: true }); + return () => mql.removeEventListener("change", hydrate); + } + } +}; +var hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => { + if (isString(interactions)) interactions = [interactions]; + let hasHydrated = false; + const doHydrate = (e) => { + if (!hasHydrated) { + hasHydrated = true; + teardown(); + hydrate(); + e.target.dispatchEvent(new e.constructor(e.type, e)); + } + }; + const teardown = () => { + forEach((el) => { + for (const i of interactions) el.removeEventListener(i, doHydrate); + }); + }; + forEach((el) => { + for (const i of interactions) el.addEventListener(i, doHydrate, { once: true }); + }); + return teardown; +}; +function forEachElement(node, cb) { + if (isComment(node) && node.data === "[") { + let depth = 1; + let next = node.nextSibling; + while (next) { + if (next.nodeType === 1) { + if (cb(next) === false) break; + } else if (isComment(next)) { + if (next.data === "]") { + if (--depth === 0) break; + } else if (next.data === "[") depth++; + } + next = next.nextSibling; + } + } else cb(node); +} +var isAsyncWrapper = (i) => !!i.type.__asyncLoader; +// @__NO_SIDE_EFFECTS__ +function defineAsyncComponent(source) { + if (isFunction(source)) source = { loader: source }; + const { loader, loadingComponent, errorComponent, delay = 200, hydrate: hydrateStrategy, timeout, suspensible = true, onError: userOnError } = source; + let pendingRequest = null; + let resolvedComp; + let retries = 0; + const retry = () => { + retries++; + pendingRequest = null; + return load(); + }; + const load = () => { + let thisRequest; + return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => { + err = err instanceof Error ? err : new Error(String(err)); + if (userOnError) return new Promise((resolve, reject) => { + const userRetry = () => resolve(retry()); + const userFail = () => reject(err); + userOnError(err, userRetry, userFail, retries + 1); + }); + else throw err; + }).then((comp) => { + if (thisRequest !== pendingRequest && pendingRequest) return pendingRequest; + if (!comp) warn$1(`Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`); + if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) comp = comp.default; + if (comp && !isObject(comp) && !isFunction(comp)) throw new Error(`Invalid async component load result: ${comp}`); + resolvedComp = comp; + return comp; + })); + }; + return /* @__PURE__ */ defineComponent({ + name: "AsyncComponentWrapper", + __asyncLoader: load, + __asyncHydrate(el, instance, hydrate) { + let patched = false; + (instance.bu || (instance.bu = [])).push(() => patched = true); + const performHydrate = () => { + if (patched) { + warn$1(`Skipping lazy hydration for component '${getComponentName(resolvedComp) || resolvedComp.__file}': it was updated before lazy hydration performed.`); + return; + } + hydrate(); + }; + const doHydrate = hydrateStrategy ? () => { + const teardown = hydrateStrategy(performHydrate, (cb) => forEachElement(el, cb)); + if (teardown) (instance.bum || (instance.bum = [])).push(teardown); + } : performHydrate; + if (resolvedComp) doHydrate(); + else load().then(() => !instance.isUnmounted && doHydrate()); + }, + get __asyncResolved() { + return resolvedComp; + }, + setup() { + const instance = currentInstance; + markAsyncBoundary(instance); + if (resolvedComp) return () => createInnerComp(resolvedComp, instance); + const onError = (err) => { + pendingRequest = null; + handleError(err, instance, 13, !errorComponent); + }; + if (suspensible && instance.suspense || isInSSRComponentSetup) return load().then((comp) => { + return () => createInnerComp(comp, instance); + }).catch((err) => { + onError(err); + return () => errorComponent ? createVNode(errorComponent, { error: err }) : null; + }); + const loaded = /* @__PURE__ */ ref(false); + const error = /* @__PURE__ */ ref(); + const delayed = /* @__PURE__ */ ref(!!delay); + let timeoutTimer; + let delayTimer; + onUnmounted(() => { + if (timeoutTimer != null) clearTimeout(timeoutTimer); + if (delayTimer != null) clearTimeout(delayTimer); + }); + if (delay) delayTimer = setTimeout(() => { + if (instance.isUnmounted) return; + delayed.value = false; + }, delay); + if (timeout != null) timeoutTimer = setTimeout(() => { + if (instance.isUnmounted) return; + if (!loaded.value && !error.value) { + const err = /* @__PURE__ */ new Error(`Async component timed out after ${timeout}ms.`); + onError(err); + error.value = err; + } + }, timeout); + load().then(() => { + if (instance.isUnmounted) return; + loaded.value = true; + if (instance.parent && isKeepAlive(instance.parent.vnode)) instance.parent.update(); + }).catch((err) => { + if (instance.isUnmounted) { + pendingRequest = null; + return; + } + onError(err); + error.value = err; + }); + return () => { + if (loaded.value && resolvedComp) return createInnerComp(resolvedComp, instance); + else if (error.value && errorComponent) return createVNode(errorComponent, { error: error.value }); + else if (loadingComponent && !delayed.value) return createInnerComp(loadingComponent, instance); + }; + } + }); +} +function createInnerComp(comp, parent) { + const { ref: ref2, props, children, ce } = parent.vnode; + const vnode = createVNode(comp, props, children); + vnode.ref = ref2; + vnode.ce = ce; + delete parent.vnode.ce; + return vnode; +} +var isKeepAlive = (vnode) => vnode.type.__isKeepAlive; +var KeepAlive = { + name: `KeepAlive`, + __isKeepAlive: true, + props: { + include: [ + String, + RegExp, + Array + ], + exclude: [ + String, + RegExp, + Array + ], + max: [String, Number] + }, + setup(props, { slots }) { + const instance = getCurrentInstance(); + const sharedContext = instance.ctx; + if (!sharedContext.renderer) return () => { + const children = slots.default && slots.default(); + return children && children.length === 1 ? children[0] : children; + }; + const cache = /* @__PURE__ */ new Map(); + const keys = /* @__PURE__ */ new Set(); + let current = null; + instance.__v_cache = cache; + const parentSuspense = instance.suspense; + const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext; + const storageContainer = createElement("div"); + sharedContext.activate = (vnode, container, anchor, namespace, optimized) => { + const instance2 = vnode.component; + move(vnode, container, anchor, 0, parentSuspense); + patch(instance2.vnode, vnode, container, anchor, instance2, parentSuspense, namespace, vnode.slotScopeIds, optimized); + queuePostRenderEffect(() => { + instance2.isDeactivated = false; + if (instance2.a) invokeArrayFns(instance2.a); + const vnodeHook = vnode.props && vnode.props.onVnodeMounted; + if (vnodeHook) invokeVNodeHook(vnodeHook, instance2.parent, vnode); + }, parentSuspense); + devtoolsComponentAdded(instance2); + }; + sharedContext.deactivate = (vnode) => { + const instance2 = vnode.component; + invalidateMount(instance2.m); + invalidateMount(instance2.a); + move(vnode, storageContainer, null, 1, parentSuspense); + queuePostRenderEffect(() => { + if (instance2.da) invokeArrayFns(instance2.da); + const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted; + if (vnodeHook) invokeVNodeHook(vnodeHook, instance2.parent, vnode); + instance2.isDeactivated = true; + }, parentSuspense); + devtoolsComponentAdded(instance2); + instance2.__keepAliveStorageContainer = storageContainer; + }; + function unmount(vnode) { + resetShapeFlag(vnode); + _unmount(vnode, instance, parentSuspense, true); + } + function pruneCache(filter) { + cache.forEach((vnode, key) => { + const name = getComponentName(isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : vnode.type); + if (name && !filter(name)) pruneCacheEntry(key); + }); + } + function pruneCacheEntry(key) { + const cached = cache.get(key); + if (cached && (!current || !isSameVNodeType(cached, current))) unmount(cached); + else if (current) resetShapeFlag(current); + cache.delete(key); + keys.delete(key); + } + watch(() => [props.include, props.exclude], ([include, exclude]) => { + include && pruneCache((name) => matches(include, name)); + exclude && pruneCache((name) => !matches(exclude, name)); + }, { + flush: "post", + deep: true + }); + let pendingCacheKey = null; + const cacheSubtree = () => { + if (pendingCacheKey != null) if (isSuspense(instance.subTree.type)) queuePostRenderEffect(() => { + cache.set(pendingCacheKey, getInnerChild(instance.subTree)); + }, instance.subTree.suspense); + else cache.set(pendingCacheKey, getInnerChild(instance.subTree)); + }; + onMounted(cacheSubtree); + onUpdated(cacheSubtree); + onBeforeUnmount(() => { + cache.forEach((cached) => { + const { subTree, suspense } = instance; + const vnode = getInnerChild(subTree); + if (cached.type === vnode.type && cached.key === vnode.key) { + resetShapeFlag(vnode); + const da = vnode.component.da; + da && queuePostRenderEffect(da, suspense); + return; + } + unmount(cached); + }); + }); + return () => { + pendingCacheKey = null; + if (!slots.default) return current = null; + const children = slots.default(); + const rawVNode = children[0]; + if (children.length > 1) { + warn$1(`KeepAlive should contain exactly one component child.`); + current = null; + return children; + } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) { + current = null; + return rawVNode; + } + let vnode = getInnerChild(rawVNode); + if (vnode.type === Comment) { + current = null; + return vnode; + } + const comp = vnode.type; + const name = getComponentName(isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp); + const { include, exclude, max } = props; + if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) { + vnode.shapeFlag &= -257; + current = vnode; + return rawVNode; + } + const key = vnode.key == null ? comp : vnode.key; + const cachedVNode = cache.get(key); + if (vnode.el) { + vnode = cloneVNode(vnode); + if (rawVNode.shapeFlag & 128) rawVNode.ssContent = vnode; + } + pendingCacheKey = key; + if (cachedVNode) { + vnode.el = cachedVNode.el; + vnode.component = cachedVNode.component; + if (vnode.transition) setTransitionHooks(vnode, vnode.transition); + vnode.shapeFlag |= 512; + keys.delete(key); + keys.add(key); + } else { + keys.add(key); + if (max && keys.size > parseInt(max, 10)) pruneCacheEntry(keys.values().next().value); + } + vnode.shapeFlag |= 256; + current = vnode; + return isSuspense(rawVNode.type) ? rawVNode : vnode; + }; + } +}; +function matches(pattern, name) { + if (isArray(pattern)) return pattern.some((p) => matches(p, name)); + else if (isString(pattern)) return pattern.split(",").includes(name); + else if (isRegExp(pattern)) { + pattern.lastIndex = 0; + return pattern.test(name); + } + return false; +} +function onActivated(hook, target) { + registerKeepAliveHook(hook, "a", target); +} +function onDeactivated(hook, target) { + registerKeepAliveHook(hook, "da", target); +} +function registerKeepAliveHook(hook, type, target = currentInstance) { + const wrappedHook = hook.__wdc || (hook.__wdc = () => { + let current = target; + while (current) { + if (current.isDeactivated) return; + current = current.parent; + } + return hook(); + }); + injectHook(type, wrappedHook, target); + if (target) { + let current = target.parent; + while (current && current.parent) { + if (isKeepAlive(current.parent.vnode)) injectToKeepAliveRoot(wrappedHook, type, target, current); + current = current.parent; + } + } +} +function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { + const injected = injectHook(type, hook, keepAliveRoot, true); + onUnmounted(() => { + remove(keepAliveRoot[type], injected); + }, target); +} +function resetShapeFlag(vnode) { + vnode.shapeFlag &= -257; + vnode.shapeFlag &= -513; +} +function getInnerChild(vnode) { + return vnode.shapeFlag & 128 ? vnode.ssContent : vnode; +} +function injectHook(type, hook, target = currentInstance, prepend = false) { + if (target) { + const hooks = target[type] || (target[type] = []); + const wrappedHook = hook.__weh || (hook.__weh = (...args) => { + pauseTracking(); + const reset = setCurrentInstance(target); + const res = callWithAsyncErrorHandling(hook, target, type, args); + reset(); + resetTracking(); + return res; + }); + if (prepend) hooks.unshift(wrappedHook); + else hooks.push(wrappedHook); + return wrappedHook; + } else warn$1(`${toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""))} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`); +} +var createHook = (lifecycle) => (hook, target = currentInstance) => { + if (!isInSSRComponentSetup || lifecycle === "sp") injectHook(lifecycle, (...args) => hook(...args), target); +}; +var onBeforeMount = createHook("bm"); +var onMounted = createHook("m"); +var onBeforeUpdate = createHook("bu"); +var onUpdated = createHook("u"); +var onBeforeUnmount = createHook("bum"); +var onUnmounted = createHook("um"); +var onServerPrefetch = createHook("sp"); +var onRenderTriggered = createHook("rtg"); +var onRenderTracked = createHook("rtc"); +function onErrorCaptured(hook, target = currentInstance) { + injectHook("ec", hook, target); +} +var COMPONENTS = "components"; +var DIRECTIVES = "directives"; +function resolveComponent(name, maybeSelfReference) { + return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name; +} +var NULL_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol.for("v-ndc"); +function resolveDynamicComponent(component) { + if (isString(component)) return resolveAsset(COMPONENTS, component, false) || component; + else return component || NULL_DYNAMIC_COMPONENT; +} +function resolveDirective(name) { + return resolveAsset(DIRECTIVES, name); +} +function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) { + const instance = currentRenderingInstance || currentInstance; + if (instance) { + const Component = instance.type; + if (type === COMPONENTS) { + const selfName = getComponentName(Component, false); + if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) return Component; + } + const res = resolve(instance[type] || Component[type], name) || resolve(instance.appContext[type], name); + if (!res && maybeSelfReference) return Component; + if (warnMissing && !res) { + const extra = type === COMPONENTS ? ` +If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``; + warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`); + } + return res; + } else warn$1(`resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`); +} +function resolve(registry, name) { + return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]); +} +function renderList(source, renderItem, cache, index) { + let ret; + const cached = cache && cache[index]; + const sourceIsArray = isArray(source); + if (sourceIsArray || isString(source)) { + const sourceIsReactiveArray = sourceIsArray && /* @__PURE__ */ isReactive(source); + let needsWrap = false; + let isReadonlySource = false; + if (sourceIsReactiveArray) { + needsWrap = !/* @__PURE__ */ isShallow(source); + isReadonlySource = /* @__PURE__ */ isReadonly(source); + source = shallowReadArray(source); + } + ret = new Array(source.length); + for (let i = 0, l = source.length; i < l; i++) ret[i] = renderItem(needsWrap ? isReadonlySource ? toReadonly(toReactive(source[i])) : toReactive(source[i]) : source[i], i, void 0, cached && cached[i]); + } else if (typeof source === "number") if (!Number.isInteger(source) || source < 0) { + warn$1(`The v-for range expects a positive integer value but got ${source}.`); + ret = []; + } else { + ret = new Array(source); + for (let i = 0; i < source; i++) ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]); + } + else if (isObject(source)) if (source[Symbol.iterator]) ret = Array.from(source, (item, i) => renderItem(item, i, void 0, cached && cached[i])); + else { + const keys = Object.keys(source); + ret = new Array(keys.length); + for (let i = 0, l = keys.length; i < l; i++) { + const key = keys[i]; + ret[i] = renderItem(source[key], key, i, cached && cached[i]); + } + } + else ret = []; + if (cache) cache[index] = ret; + return ret; +} +function createSlots(slots, dynamicSlots) { + for (let i = 0; i < dynamicSlots.length; i++) { + const slot = dynamicSlots[i]; + if (isArray(slot)) for (let j = 0; j < slot.length; j++) slots[slot[j].name] = slot[j].fn; + else if (slot) slots[slot.name] = slot.key ? (...args) => { + const res = slot.fn(...args); + if (res) res.key = slot.key; + return res; + } : slot.fn; + } + return slots; +} +function renderSlot(slots, name, props = {}, fallback, noSlotted) { + if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) { + const hasProps = Object.keys(props).length > 0; + if (name !== "default") props.name = name; + return openBlock(), createBlock(Fragment, null, [createVNode("slot", props, fallback && fallback())], hasProps ? -2 : 64); + } + let slot = slots[name]; + if (slot && slot.length > 1) { + warn$1(`SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.`); + slot = () => []; + } + if (slot && slot._c) slot._d = false; + openBlock(); + const validSlotContent = slot && ensureValidVNode(slot(props)); + const slotKey = props.key || validSlotContent && validSlotContent.key; + const rendered = createBlock(Fragment, { key: (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) + (!validSlotContent && fallback ? "_fb" : "") }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 ? 64 : -2); + if (!noSlotted && rendered.scopeId) rendered.slotScopeIds = [rendered.scopeId + "-s"]; + if (slot && slot._c) slot._d = true; + return rendered; +} +function ensureValidVNode(vnodes) { + return vnodes.some((child) => { + if (!isVNode(child)) return true; + if (child.type === Comment) return false; + if (child.type === Fragment && !ensureValidVNode(child.children)) return false; + return true; + }) ? vnodes : null; +} +function toHandlers(obj, preserveCaseIfNecessary) { + const ret = {}; + if (!isObject(obj)) { + warn$1(`v-on with no argument expects an object value.`); + return ret; + } + for (const key in obj) ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key]; + return ret; +} +var getPublicInstance = (i) => { + if (!i) return null; + if (isStatefulComponent(i)) return getComponentPublicInstance(i); + return getPublicInstance(i.parent); +}; +var publicPropertiesMap = /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), { + $: (i) => i, + $el: (i) => i.vnode.el, + $data: (i) => i.data, + $props: (i) => /* @__PURE__ */ shallowReadonly(i.props), + $attrs: (i) => /* @__PURE__ */ shallowReadonly(i.attrs), + $slots: (i) => /* @__PURE__ */ shallowReadonly(i.slots), + $refs: (i) => /* @__PURE__ */ shallowReadonly(i.refs), + $parent: (i) => getPublicInstance(i.parent), + $root: (i) => getPublicInstance(i.root), + $host: (i) => i.ce, + $emit: (i) => i.emit, + $options: (i) => __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type, + $forceUpdate: (i) => i.f || (i.f = () => { + queueJob(i.update); + }), + $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)), + $watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP +}); +var isReservedPrefix = (key) => key === "_" || key === "$"; +var hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key); +var PublicInstanceProxyHandlers = { + get({ _: instance }, key) { + if (key === "__v_skip") return true; + const { ctx, setupState, data, props, accessCache, type, appContext } = instance; + if (key === "__isVue") return true; + if (key[0] !== "$") { + const n = accessCache[key]; + if (n !== void 0) switch (n) { + case 1: return setupState[key]; + case 2: return data[key]; + case 4: return ctx[key]; + case 3: return props[key]; + } + else if (hasSetupBinding(setupState, key)) { + accessCache[key] = 1; + return setupState[key]; + } else if (__VUE_OPTIONS_API__ && data !== EMPTY_OBJ && hasOwn(data, key)) { + accessCache[key] = 2; + return data[key]; + } else if (hasOwn(props, key)) { + accessCache[key] = 3; + return props[key]; + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 4; + return ctx[key]; + } else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) accessCache[key] = 0; + } + const publicGetter = publicPropertiesMap[key]; + let cssModule, globalProperties; + if (publicGetter) { + if (key === "$attrs") { + track(instance.attrs, "get", ""); + markAttrsAccessed(); + } else if (key === "$slots") track(instance, "get", key); + return publicGetter(instance); + } else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) return cssModule; + else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 4; + return ctx[key]; + } else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) return globalProperties[key]; + else if (currentRenderingInstance && (!isString(key) || key.indexOf("__v") !== 0)) { + if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) warn$1(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`); + else if (instance === currentRenderingInstance) warn$1(`Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`); + } + }, + set({ _: instance }, key, value) { + const { data, setupState, ctx } = instance; + if (hasSetupBinding(setupState, key)) { + setupState[key] = value; + return true; + } else if (setupState.__isScriptSetup && hasOwn(setupState, key)) { + warn$1(`Cannot mutate +``` + +(It also works with various module systems, if you prefer that sort of thing - it has a dependency on [vlq](https://github.com/Rich-Harris/vlq).) + +## Usage + +These examples assume you're in node.js, or something similar: + +```js +import MagicString from 'magic-string'; +import fs from 'fs'; + +const s = new MagicString('problems = 99'); + +s.update(0, 8, 'answer'); +s.toString(); // 'answer = 99' + +s.update(11, 13, '42'); // character indices always refer to the original string +s.toString(); // 'answer = 42' + +s.prepend('var ').append(';'); // most methods are chainable +s.toString(); // 'var answer = 42;' + +const map = s.generateMap({ + source: 'source.js', + file: 'converted.js.map', + includeContent: true, +}); // generates a v3 sourcemap + +fs.writeFileSync('converted.js', s.toString()); +fs.writeFileSync('converted.js.map', map.toString()); +``` + +You can pass an options argument: + +```js +const s = new MagicString(someCode, { + // these options will be used if you later call `bundle.addSource( s )` - see below + filename: 'foo.js', + indentExclusionRanges: [ + /*...*/ + ], + // mark source as ignore in DevTools, see below #Bundling + ignoreList: false, + // adjust the incoming position - see below + offset: 0, +}); +``` + +## Properties + +### s.offset + +Sets the offset property to adjust the incoming position for the following APIs: `slice`, `update`, `overwrite`, `appendLeft`, `prependLeft`, `appendRight`, `prependRight`, `move`, `reset`, and `remove`. + +Example usage: + +```ts +const s = new MagicString('hello world', { offset: 0 }); +s.offset = 6; +s.slice() === 'world'; +``` + +## Methods + +### s.addSourcemapLocation( index ) + +Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is `false` (see below). + +### s.append( content ) + +Appends the specified content to the end of the string. Returns `this`. + +### s.appendLeft( index, content ) + +Appends the specified `content` at the `index` in the original string. If a range _ending_ with `index` is subsequently moved, the insert will be moved with it. Returns `this`. See also `s.prependLeft(...)`. + +### s.appendRight( index, content ) + +Appends the specified `content` at the `index` in the original string. If a range _starting_ with `index` is subsequently moved, the insert will be moved with it. Returns `this`. See also `s.prependRight(...)`. + +### s.clone() + +Does what you'd expect. + +### s.generateDecodedMap( options ) + +Generates a sourcemap object with raw mappings in array form, rather than encoded as a string. See `generateMap` documentation below for options details. Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead. + +### s.generateMap( options ) + +Generates a [version 3 sourcemap](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit). All options are, well, optional: + +- `file` - the filename where you plan to write the sourcemap +- `source` - the filename of the file containing the original source +- `includeContent` - whether to include the original content in the map's `sourcesContent` array +- `hires` - whether the mapping should be high-resolution. Hi-res mappings map every single character, meaning (for example) your devtools will always be able to pinpoint the exact location of function calls and so on. With lo-res mappings, devtools may only be able to identify the correct line - but they're quicker to generate and less bulky. You can also set `"boundary"` to generate a semi-hi-res mappings segmented per word boundary instead of per character, suitable for string semantics that are separated by words. If sourcemap locations have been specified with `s.addSourcemapLocation()`, they will be used here. + +The returned sourcemap has two (non-enumerable) methods attached for convenience: + +- `toString` - returns the equivalent of `JSON.stringify(map)` +- `toUrl` - returns a DataURI containing the sourcemap. Useful for doing this sort of thing: + +```js +code += '\n//# sourceMappingURL=' + map.toUrl(); +``` + +### s.hasChanged() + +Indicates if the string has been changed. + +### s.indent( prefix[, options] ) + +Prefixes each line of the string with `prefix`. If `prefix` is not supplied, the indentation will be guessed from the original content, falling back to a single tab character. Returns `this`. + +The `options` argument can have an `exclude` property, which is an array of `[start, end]` character ranges. These ranges will be excluded from the indentation - useful for (e.g.) multiline strings. + +### s.insertLeft( index, content ) + +**DEPRECATED** since 0.17 – use `s.appendLeft(...)` instead + +### s.insertRight( index, content ) + +**DEPRECATED** since 0.17 – use `s.prependRight(...)` instead + +### s.isEmpty() + +Returns true if the resulting source is empty (disregarding white space). + +### s.locate( index ) + +**DEPRECATED** since 0.10 – see [#30](https://github.com/Rich-Harris/magic-string/pull/30) + +### s.locateOrigin( index ) + +**DEPRECATED** since 0.10 – see [#30](https://github.com/Rich-Harris/magic-string/pull/30) + +### s.move( start, end, index ) + +Moves the characters from `start` and `end` to `index`. Returns `this`. + +### s.overwrite( start, end, content[, options] ) + +Replaces the characters from `start` to `end` with `content`, along with the appended/prepended content in that range. The same restrictions as `s.remove()` apply. Returns `this`. + +The fourth argument is optional. It can have a `storeName` property — if `true`, the original name will be stored for later inclusion in a sourcemap's `names` array — and a `contentOnly` property which determines whether only the content is overwritten, or anything that was appended/prepended to the range as well. + +It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content. + +### s.prepend( content ) + +Prepends the string with the specified content. Returns `this`. + +### s.prependLeft ( index, content ) + +Same as `s.appendLeft(...)`, except that the inserted content will go _before_ any previous appends or prepends at `index` + +### s.prependRight ( index, content ) + +Same as `s.appendRight(...)`, except that the inserted content will go _before_ any previous appends or prepends at `index` + +### s.replace( regexpOrString, substitution ) + +String replacement with RegExp or string. The `substitution` parameter supports strings and functions. Returns `this`. + +```ts +import MagicString from 'magic-string'; + +const s = new MagicString(source); + +s.replace('foo', 'bar'); +s.replace('foo', (str, index, s) => str + '-' + index); +s.replace(/foo/g, 'bar'); +s.replace(/(\w)(\d+)/g, (_, $1, $2) => $1.toUpperCase() + $2); +``` + +The differences from [`String.replace`](<(https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace)>): + +- It will always match against the **original string** +- It mutates the magic string state (use `.clone()` to be immutable) + +### s.replaceAll( regexpOrString, substitution ) + +Same as `s.replace`, but replace all matched strings instead of just one. +If `regexpOrString` is a regex, then it must have the global (`g`) flag set, or a `TypeError` is thrown. Matches the behavior of the builtin [`String.property.replaceAll`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll). Returns `this`. + +### s.remove( start, end ) + +Removes the characters from `start` to `end` (of the original string, **not** the generated string). Removing the same content twice, or making removals that partially overlap, will cause an error. Returns `this`. + +### s.reset( start, end ) + +Resets the characters from `start` to `end` (of the original string, **not** the generated string). +It can be used to restore previously removed characters and discard unwanted changes. + +### s.slice( start, end ) + +Returns the content of the generated string that corresponds to the slice between `start` and `end` of the original string. Throws error if the indices are for characters that were already removed. + +### s.snip( start, end ) + +Returns a clone of `s`, with all content before the `start` and `end` characters of the original string removed. + +### s.toString() + +Returns the generated string. + +### s.trim([ charType ]) + +Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start and end. Returns `this`. + +### s.trimStart([ charType ]) + +Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start. Returns `this`. + +### s.trimEnd([ charType ]) + +Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end. Returns `this`. + +### s.trimLines() + +Removes empty lines from the start and end. Returns `this`. + +### s.update( start, end, content[, options] ) + +Replaces the characters from `start` to `end` with `content`. The same restrictions as `s.remove()` apply. Returns `this`. + +The fourth argument is optional. It can have a `storeName` property — if `true`, the original name will be stored for later inclusion in a sourcemap's `names` array — and an `overwrite` property which defaults to `false` and determines whether anything that was appended/prepended to the range will be overwritten along with the original content. + +`s.update(start, end, content)` is equivalent to `s.overwrite(start, end, content, { contentOnly: true })`. + +## Bundling + +To concatenate several sources, use `MagicString.Bundle`: + +```js +const bundle = new MagicString.Bundle(); + +bundle.addSource({ + filename: 'foo.js', + content: new MagicString('var answer = 42;'), +}); + +bundle.addSource({ + filename: 'bar.js', + content: new MagicString('console.log( answer )'), +}); + +// Sources can be marked as ignore-listed, which provides a hint to debuggers +// to not step into this code and also don't show the source files depending +// on user preferences. +bundle.addSource({ + filename: 'some-3rdparty-library.js', + content: new MagicString('function myLib(){}'), + ignoreList: false, // <-- +}); + +// Advanced: a source can include an `indentExclusionRanges` property +// alongside `filename` and `content`. This will be passed to `s.indent()` +// - see documentation above + +bundle + .indent() // optionally, pass an indent string, otherwise it will be guessed + .prepend('(function () {\n') + .append('}());'); + +bundle.toString(); +// (function () { +// var answer = 42; +// console.log( answer ); +// }()); + +// options are as per `s.generateMap()` above +const map = bundle.generateMap({ + file: 'bundle.js', + includeContent: true, + hires: true, +}); +``` + +As an alternative syntax, if you a) don't have `filename` or `indentExclusionRanges` options, or b) passed those in when you used `new MagicString(...)`, you can simply pass the `MagicString` instance itself: + +```js +const bundle = new MagicString.Bundle(); +const source = new MagicString(someCode, { + filename: 'foo.js', +}); + +bundle.addSource(source); +``` + +## License + +MIT diff --git a/frontend/node_modules/magic-string/dist/magic-string.cjs.d.ts b/frontend/node_modules/magic-string/dist/magic-string.cjs.d.ts new file mode 100644 index 0000000..76cc537 --- /dev/null +++ b/frontend/node_modules/magic-string/dist/magic-string.cjs.d.ts @@ -0,0 +1,289 @@ +export interface BundleOptions { + intro?: string; + separator?: string; +} + +export interface SourceMapOptions { + /** + * Whether the mapping should be high-resolution. + * Hi-res mappings map every single character, meaning (for example) your devtools will always + * be able to pinpoint the exact location of function calls and so on. + * With lo-res mappings, devtools may only be able to identify the correct + * line - but they're quicker to generate and less bulky. + * You can also set `"boundary"` to generate a semi-hi-res mappings segmented per word boundary + * instead of per character, suitable for string semantics that are separated by words. + * If sourcemap locations have been specified with s.addSourceMapLocation(), they will be used here. + */ + hires?: boolean | 'boundary'; + /** + * The filename where you plan to write the sourcemap. + */ + file?: string; + /** + * The filename of the file containing the original source. + */ + source?: string; + /** + * Whether to include the original content in the map's sourcesContent array. + */ + includeContent?: boolean; +} + +export type SourceMapSegment = + | [number] + | [number, number, number, number] + | [number, number, number, number, number]; + +export interface DecodedSourceMap { + file: string; + sources: string[]; + sourcesContent?: string[]; + names: string[]; + mappings: SourceMapSegment[][]; + x_google_ignoreList?: number[]; +} + +export class SourceMap { + constructor(properties: DecodedSourceMap); + + version: number; + file: string; + sources: string[]; + sourcesContent?: string[]; + names: string[]; + mappings: string; + x_google_ignoreList?: number[]; + debugId?: string; + + /** + * Returns the equivalent of `JSON.stringify(map)` + */ + toString(): string; + /** + * Returns a DataURI containing the sourcemap. Useful for doing this sort of thing: + * `generateMap(options?: SourceMapOptions): SourceMap;` + */ + toUrl(): string; +} + +export class Bundle { + constructor(options?: BundleOptions); + /** + * Adds the specified source to the bundle, which can either be a `MagicString` object directly, + * or an options object that holds a magic string `content` property and optionally provides + * a `filename` for the source within the bundle, as well as an optional `ignoreList` hint + * (which defaults to `false`). The `filename` is used when constructing the source map for the + * bundle, to identify this `source` in the source map's `sources` field. The `ignoreList` hint + * is used to populate the `x_google_ignoreList` extension field in the source map, which is a + * mechanism for tools to signal to debuggers that certain sources should be ignored by default + * (depending on user preferences). + */ + addSource( + source: MagicString | { filename?: string; content: MagicString; ignoreList?: boolean }, + ): this; + append(str: string, options?: BundleOptions): this; + clone(): this; + generateMap( + options?: SourceMapOptions, + ): Omit & { sourcesContent: Array }; + generateDecodedMap( + options?: SourceMapOptions, + ): Omit & { sourcesContent: Array }; + getIndentString(): string; + indent(indentStr?: string): this; + indentExclusionRanges: ExclusionRange | Array; + prepend(str: string): this; + toString(): string; + trimLines(): this; + trim(charType?: string): this; + trimStart(charType?: string): this; + trimEnd(charType?: string): this; + isEmpty(): boolean; + length(): number; +} + +export type ExclusionRange = [number, number]; + +export interface MagicStringOptions { + filename?: string; + indentExclusionRanges?: ExclusionRange | Array; + offset?: number; +} + +export interface IndentOptions { + exclude?: ExclusionRange | Array; + indentStart?: boolean; +} + +export interface OverwriteOptions { + storeName?: boolean; + contentOnly?: boolean; +} + +export interface UpdateOptions { + storeName?: boolean; + overwrite?: boolean; +} + +export default class MagicString { + constructor(str: string, options?: MagicStringOptions); + /** + * Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is false. + */ + addSourcemapLocation(char: number): void; + /** + * Appends the specified content to the end of the string. + */ + append(content: string): this; + /** + * Appends the specified content at the index in the original string. + * If a range *ending* with index is subsequently moved, the insert will be moved with it. + * See also `s.prependLeft(...)`. + */ + appendLeft(index: number, content: string): this; + /** + * Appends the specified content at the index in the original string. + * If a range *starting* with index is subsequently moved, the insert will be moved with it. + * See also `s.prependRight(...)`. + */ + appendRight(index: number, content: string): this; + /** + * Does what you'd expect. + */ + clone(): this; + /** + * Generates a version 3 sourcemap. + */ + generateMap(options?: SourceMapOptions): SourceMap; + /** + * Generates a sourcemap object with raw mappings in array form, rather than encoded as a string. + * Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead. + */ + generateDecodedMap(options?: SourceMapOptions): DecodedSourceMap; + getIndentString(): string; + + /** + * Prefixes each line of the string with prefix. + * If prefix is not supplied, the indentation will be guessed from the original content, falling back to a single tab character. + */ + indent(options?: IndentOptions): this; + /** + * Prefixes each line of the string with prefix. + * If prefix is not supplied, the indentation will be guessed from the original content, falling back to a single tab character. + * + * The options argument can have an exclude property, which is an array of [start, end] character ranges. + * These ranges will be excluded from the indentation - useful for (e.g.) multiline strings. + */ + indent(indentStr?: string, options?: IndentOptions): this; + indentExclusionRanges: ExclusionRange | Array; + + /** + * Moves the characters from `start` and `end` to `index`. + */ + move(start: number, end: number, index: number): this; + /** + * Replaces the characters from `start` to `end` with `content`, along with the appended/prepended content in + * that range. The same restrictions as `s.remove()` apply. + * + * The fourth argument is optional. It can have a storeName property — if true, the original name will be stored + * for later inclusion in a sourcemap's names array — and a contentOnly property which determines whether only + * the content is overwritten, or anything that was appended/prepended to the range as well. + * + * It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content. + */ + overwrite( + start: number, + end: number, + content: string, + options?: boolean | OverwriteOptions, + ): this; + /** + * Replaces the characters from `start` to `end` with `content`. The same restrictions as `s.remove()` apply. + * + * The fourth argument is optional. It can have a storeName property — if true, the original name will be stored + * for later inclusion in a sourcemap's names array — and an overwrite property which determines whether only + * the content is overwritten, or anything that was appended/prepended to the range as well. + */ + update(start: number, end: number, content: string, options?: boolean | UpdateOptions): this; + /** + * Prepends the string with the specified content. + */ + prepend(content: string): this; + /** + * Same as `s.appendLeft(...)`, except that the inserted content will go *before* any previous appends or prepends at index + */ + prependLeft(index: number, content: string): this; + /** + * Same as `s.appendRight(...)`, except that the inserted content will go *before* any previous appends or prepends at `index` + */ + prependRight(index: number, content: string): this; + /** + * Removes the characters from `start` to `end` (of the original string, **not** the generated string). + * Removing the same content twice, or making removals that partially overlap, will cause an error. + */ + remove(start: number, end: number): this; + /** + * Reset the modified characters from `start` to `end` (of the original string, **not** the generated string). + */ + reset(start: number, end: number): this; + /** + * Returns the content of the generated string that corresponds to the slice between `start` and `end` of the original string. + * Throws error if the indices are for characters that were already removed. + */ + slice(start: number, end: number): string; + /** + * Returns a clone of `s`, with all content before the `start` and `end` characters of the original string removed. + */ + snip(start: number, end: number): this; + /** + * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start and end. + */ + trim(charType?: string): this; + /** + * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start. + */ + trimStart(charType?: string): this; + /** + * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end. + */ + trimEnd(charType?: string): this; + /** + * Removes empty lines from the start and end. + */ + trimLines(): this; + /** + * String replacement with RegExp or string. + */ + replace( + regex: RegExp | string, + replacement: string | ((substring: string, ...args: any[]) => string), + ): this; + /** + * Same as `s.replace`, but replace all matched strings instead of just one. + */ + replaceAll( + regex: RegExp | string, + replacement: string | ((substring: string, ...args: any[]) => string), + ): this; + + lastChar(): string; + lastLine(): string; + /** + * Returns true if the resulting source is empty (disregarding white space). + */ + isEmpty(): boolean; + length(): number; + + /** + * Indicates if the string has been changed. + */ + hasChanged(): boolean; + + original: string; + /** + * Returns the generated string. + */ + toString(): string; + + offset: number; +} diff --git a/frontend/node_modules/magic-string/dist/magic-string.cjs.js b/frontend/node_modules/magic-string/dist/magic-string.cjs.js new file mode 100644 index 0000000..bf3cd1d --- /dev/null +++ b/frontend/node_modules/magic-string/dist/magic-string.cjs.js @@ -0,0 +1,1594 @@ +'use strict'; + +var sourcemapCodec = require('@jridgewell/sourcemap-codec'); + +class BitSet { + constructor(arg) { + this.bits = arg instanceof BitSet ? arg.bits.slice() : []; + } + + add(n) { + this.bits[n >> 5] |= 1 << (n & 31); + } + + has(n) { + return !!(this.bits[n >> 5] & (1 << (n & 31))); + } +} + +class Chunk { + constructor(start, end, content) { + this.start = start; + this.end = end; + this.original = content; + + this.intro = ''; + this.outro = ''; + + this.content = content; + this.storeName = false; + this.edited = false; + + { + this.previous = null; + this.next = null; + } + } + + appendLeft(content) { + this.outro += content; + } + + appendRight(content) { + this.intro = this.intro + content; + } + + clone() { + const chunk = new Chunk(this.start, this.end, this.original); + + chunk.intro = this.intro; + chunk.outro = this.outro; + chunk.content = this.content; + chunk.storeName = this.storeName; + chunk.edited = this.edited; + + return chunk; + } + + contains(index) { + return this.start < index && index < this.end; + } + + eachNext(fn) { + let chunk = this; + while (chunk) { + fn(chunk); + chunk = chunk.next; + } + } + + eachPrevious(fn) { + let chunk = this; + while (chunk) { + fn(chunk); + chunk = chunk.previous; + } + } + + edit(content, storeName, contentOnly) { + this.content = content; + if (!contentOnly) { + this.intro = ''; + this.outro = ''; + } + this.storeName = storeName; + + this.edited = true; + + return this; + } + + prependLeft(content) { + this.outro = content + this.outro; + } + + prependRight(content) { + this.intro = content + this.intro; + } + + reset() { + this.intro = ''; + this.outro = ''; + if (this.edited) { + this.content = this.original; + this.storeName = false; + this.edited = false; + } + } + + split(index) { + const sliceIndex = index - this.start; + + const originalBefore = this.original.slice(0, sliceIndex); + const originalAfter = this.original.slice(sliceIndex); + + this.original = originalBefore; + + const newChunk = new Chunk(index, this.end, originalAfter); + newChunk.outro = this.outro; + this.outro = ''; + + this.end = index; + + if (this.edited) { + // after split we should save the edit content record into the correct chunk + // to make sure sourcemap correct + // For example: + // ' test'.trim() + // split -> ' ' + 'test' + // ✔️ edit -> '' + 'test' + // ✖️ edit -> 'test' + '' + // TODO is this block necessary?... + newChunk.edit('', false); + this.content = ''; + } else { + this.content = originalBefore; + } + + newChunk.next = this.next; + if (newChunk.next) newChunk.next.previous = newChunk; + newChunk.previous = this; + this.next = newChunk; + + return newChunk; + } + + toString() { + return this.intro + this.content + this.outro; + } + + trimEnd(rx) { + this.outro = this.outro.replace(rx, ''); + if (this.outro.length) return true; + + const trimmed = this.content.replace(rx, ''); + + if (trimmed.length) { + if (trimmed !== this.content) { + this.split(this.start + trimmed.length).edit('', undefined, true); + if (this.edited) { + // save the change, if it has been edited + this.edit(trimmed, this.storeName, true); + } + } + return true; + } else { + this.edit('', undefined, true); + + this.intro = this.intro.replace(rx, ''); + if (this.intro.length) return true; + } + } + + trimStart(rx) { + this.intro = this.intro.replace(rx, ''); + if (this.intro.length) return true; + + const trimmed = this.content.replace(rx, ''); + + if (trimmed.length) { + if (trimmed !== this.content) { + const newChunk = this.split(this.end - trimmed.length); + if (this.edited) { + // save the change, if it has been edited + newChunk.edit(trimmed, this.storeName, true); + } + this.edit('', undefined, true); + } + return true; + } else { + this.edit('', undefined, true); + + this.outro = this.outro.replace(rx, ''); + if (this.outro.length) return true; + } + } +} + +function getBtoa() { + if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') { + return (str) => globalThis.btoa(unescape(encodeURIComponent(str))); + } else if (typeof Buffer === 'function') { + return (str) => Buffer.from(str, 'utf-8').toString('base64'); + } else { + return () => { + throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.'); + }; + } +} + +const btoa = /*#__PURE__*/ getBtoa(); + +class SourceMap { + constructor(properties) { + this.version = 3; + this.file = properties.file; + this.sources = properties.sources; + this.sourcesContent = properties.sourcesContent; + this.names = properties.names; + this.mappings = sourcemapCodec.encode(properties.mappings); + if (typeof properties.x_google_ignoreList !== 'undefined') { + this.x_google_ignoreList = properties.x_google_ignoreList; + } + if (typeof properties.debugId !== 'undefined') { + this.debugId = properties.debugId; + } + } + + toString() { + return JSON.stringify(this); + } + + toUrl() { + return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString()); + } +} + +function guessIndent(code) { + const lines = code.split('\n'); + + const tabbed = lines.filter((line) => /^\t+/.test(line)); + const spaced = lines.filter((line) => /^ {2,}/.test(line)); + + if (tabbed.length === 0 && spaced.length === 0) { + return null; + } + + // More lines tabbed than spaced? Assume tabs, and + // default to tabs in the case of a tie (or nothing + // to go on) + if (tabbed.length >= spaced.length) { + return '\t'; + } + + // Otherwise, we need to guess the multiple + const min = spaced.reduce((previous, current) => { + const numSpaces = /^ +/.exec(current)[0].length; + return Math.min(numSpaces, previous); + }, Infinity); + + return new Array(min + 1).join(' '); +} + +function getRelativePath(from, to) { + const fromParts = from.split(/[/\\]/); + const toParts = to.split(/[/\\]/); + + fromParts.pop(); // get dirname + + while (fromParts[0] === toParts[0]) { + fromParts.shift(); + toParts.shift(); + } + + if (fromParts.length) { + let i = fromParts.length; + while (i--) fromParts[i] = '..'; + } + + return fromParts.concat(toParts).join('/'); +} + +const toString = Object.prototype.toString; + +function isObject(thing) { + return toString.call(thing) === '[object Object]'; +} + +function getLocator(source) { + const originalLines = source.split('\n'); + const lineOffsets = []; + + for (let i = 0, pos = 0; i < originalLines.length; i++) { + lineOffsets.push(pos); + pos += originalLines[i].length + 1; + } + + return function locate(index) { + let i = 0; + let j = lineOffsets.length; + while (i < j) { + const m = (i + j) >> 1; + if (index < lineOffsets[m]) { + j = m; + } else { + i = m + 1; + } + } + const line = i - 1; + const column = index - lineOffsets[line]; + return { line, column }; + }; +} + +const wordRegex = /\w/; + +class Mappings { + constructor(hires) { + this.hires = hires; + this.generatedCodeLine = 0; + this.generatedCodeColumn = 0; + this.raw = []; + this.rawSegments = this.raw[this.generatedCodeLine] = []; + this.pending = null; + } + + addEdit(sourceIndex, content, loc, nameIndex) { + if (content.length) { + const contentLengthMinusOne = content.length - 1; + let contentLineEnd = content.indexOf('\n', 0); + let previousContentLineEnd = -1; + // Loop through each line in the content and add a segment, but stop if the last line is empty, + // else code afterwards would fill one line too many + while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) { + const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; + if (nameIndex >= 0) { + segment.push(nameIndex); + } + this.rawSegments.push(segment); + + this.generatedCodeLine += 1; + this.raw[this.generatedCodeLine] = this.rawSegments = []; + this.generatedCodeColumn = 0; + + previousContentLineEnd = contentLineEnd; + contentLineEnd = content.indexOf('\n', contentLineEnd + 1); + } + + const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; + if (nameIndex >= 0) { + segment.push(nameIndex); + } + this.rawSegments.push(segment); + + this.advance(content.slice(previousContentLineEnd + 1)); + } else if (this.pending) { + this.rawSegments.push(this.pending); + this.advance(content); + } + + this.pending = null; + } + + addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) { + let originalCharIndex = chunk.start; + let first = true; + // when iterating each char, check if it's in a word boundary + let charInHiresBoundary = false; + + while (originalCharIndex < chunk.end) { + if (original[originalCharIndex] === '\n') { + loc.line += 1; + loc.column = 0; + this.generatedCodeLine += 1; + this.raw[this.generatedCodeLine] = this.rawSegments = []; + this.generatedCodeColumn = 0; + first = true; + charInHiresBoundary = false; + } else { + if (this.hires || first || sourcemapLocations.has(originalCharIndex)) { + const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; + + if (this.hires === 'boundary') { + // in hires "boundary", group segments per word boundary than per char + if (wordRegex.test(original[originalCharIndex])) { + // for first char in the boundary found, start the boundary by pushing a segment + if (!charInHiresBoundary) { + this.rawSegments.push(segment); + charInHiresBoundary = true; + } + } else { + // for non-word char, end the boundary by pushing a segment + this.rawSegments.push(segment); + charInHiresBoundary = false; + } + } else { + this.rawSegments.push(segment); + } + } + + loc.column += 1; + this.generatedCodeColumn += 1; + first = false; + } + + originalCharIndex += 1; + } + + this.pending = null; + } + + advance(str) { + if (!str) return; + + const lines = str.split('\n'); + + if (lines.length > 1) { + for (let i = 0; i < lines.length - 1; i++) { + this.generatedCodeLine++; + this.raw[this.generatedCodeLine] = this.rawSegments = []; + } + this.generatedCodeColumn = 0; + } + + this.generatedCodeColumn += lines[lines.length - 1].length; + } +} + +const n = '\n'; + +const warned = { + insertLeft: false, + insertRight: false, + storeName: false, +}; + +class MagicString { + constructor(string, options = {}) { + const chunk = new Chunk(0, string.length, string); + + Object.defineProperties(this, { + original: { writable: true, value: string }, + outro: { writable: true, value: '' }, + intro: { writable: true, value: '' }, + firstChunk: { writable: true, value: chunk }, + lastChunk: { writable: true, value: chunk }, + lastSearchedChunk: { writable: true, value: chunk }, + byStart: { writable: true, value: {} }, + byEnd: { writable: true, value: {} }, + filename: { writable: true, value: options.filename }, + indentExclusionRanges: { writable: true, value: options.indentExclusionRanges }, + sourcemapLocations: { writable: true, value: new BitSet() }, + storedNames: { writable: true, value: {} }, + indentStr: { writable: true, value: undefined }, + ignoreList: { writable: true, value: options.ignoreList }, + offset: { writable: true, value: options.offset || 0 }, + }); + + this.byStart[0] = chunk; + this.byEnd[string.length] = chunk; + } + + addSourcemapLocation(char) { + this.sourcemapLocations.add(char); + } + + append(content) { + if (typeof content !== 'string') throw new TypeError('outro content must be a string'); + + this.outro += content; + return this; + } + + appendLeft(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byEnd[index]; + + if (chunk) { + chunk.appendLeft(content); + } else { + this.intro += content; + } + return this; + } + + appendRight(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byStart[index]; + + if (chunk) { + chunk.appendRight(content); + } else { + this.outro += content; + } + return this; + } + + clone() { + const cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset }); + + let originalChunk = this.firstChunk; + let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone()); + + while (originalChunk) { + cloned.byStart[clonedChunk.start] = clonedChunk; + cloned.byEnd[clonedChunk.end] = clonedChunk; + + const nextOriginalChunk = originalChunk.next; + const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone(); + + if (nextClonedChunk) { + clonedChunk.next = nextClonedChunk; + nextClonedChunk.previous = clonedChunk; + + clonedChunk = nextClonedChunk; + } + + originalChunk = nextOriginalChunk; + } + + cloned.lastChunk = clonedChunk; + + if (this.indentExclusionRanges) { + cloned.indentExclusionRanges = this.indentExclusionRanges.slice(); + } + + cloned.sourcemapLocations = new BitSet(this.sourcemapLocations); + + cloned.intro = this.intro; + cloned.outro = this.outro; + + return cloned; + } + + generateDecodedMap(options) { + options = options || {}; + + const sourceIndex = 0; + const names = Object.keys(this.storedNames); + const mappings = new Mappings(options.hires); + + const locate = getLocator(this.original); + + if (this.intro) { + mappings.advance(this.intro); + } + + this.firstChunk.eachNext((chunk) => { + const loc = locate(chunk.start); + + if (chunk.intro.length) mappings.advance(chunk.intro); + + if (chunk.edited) { + mappings.addEdit( + sourceIndex, + chunk.content, + loc, + chunk.storeName ? names.indexOf(chunk.original) : -1, + ); + } else { + mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations); + } + + if (chunk.outro.length) mappings.advance(chunk.outro); + }); + + if (this.outro) { + mappings.advance(this.outro); + } + + return { + file: options.file ? options.file.split(/[/\\]/).pop() : undefined, + sources: [ + options.source ? getRelativePath(options.file || '', options.source) : options.file || '', + ], + sourcesContent: options.includeContent ? [this.original] : undefined, + names, + mappings: mappings.raw, + x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined, + }; + } + + generateMap(options) { + return new SourceMap(this.generateDecodedMap(options)); + } + + _ensureindentStr() { + if (this.indentStr === undefined) { + this.indentStr = guessIndent(this.original); + } + } + + _getRawIndentString() { + this._ensureindentStr(); + return this.indentStr; + } + + getIndentString() { + this._ensureindentStr(); + return this.indentStr === null ? '\t' : this.indentStr; + } + + indent(indentStr, options) { + const pattern = /^[^\r\n]/gm; + + if (isObject(indentStr)) { + options = indentStr; + indentStr = undefined; + } + + if (indentStr === undefined) { + this._ensureindentStr(); + indentStr = this.indentStr || '\t'; + } + + if (indentStr === '') return this; // noop + + options = options || {}; + + // Process exclusion ranges + const isExcluded = {}; + + if (options.exclude) { + const exclusions = + typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude; + exclusions.forEach((exclusion) => { + for (let i = exclusion[0]; i < exclusion[1]; i += 1) { + isExcluded[i] = true; + } + }); + } + + let shouldIndentNextCharacter = options.indentStart !== false; + const replacer = (match) => { + if (shouldIndentNextCharacter) return `${indentStr}${match}`; + shouldIndentNextCharacter = true; + return match; + }; + + this.intro = this.intro.replace(pattern, replacer); + + let charIndex = 0; + let chunk = this.firstChunk; + + while (chunk) { + const end = chunk.end; + + if (chunk.edited) { + if (!isExcluded[charIndex]) { + chunk.content = chunk.content.replace(pattern, replacer); + + if (chunk.content.length) { + shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n'; + } + } + } else { + charIndex = chunk.start; + + while (charIndex < end) { + if (!isExcluded[charIndex]) { + const char = this.original[charIndex]; + + if (char === '\n') { + shouldIndentNextCharacter = true; + } else if (char !== '\r' && shouldIndentNextCharacter) { + shouldIndentNextCharacter = false; + + if (charIndex === chunk.start) { + chunk.prependRight(indentStr); + } else { + this._splitChunk(chunk, charIndex); + chunk = chunk.next; + chunk.prependRight(indentStr); + } + } + } + + charIndex += 1; + } + } + + charIndex = chunk.end; + chunk = chunk.next; + } + + this.outro = this.outro.replace(pattern, replacer); + + return this; + } + + insert() { + throw new Error( + 'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)', + ); + } + + insertLeft(index, content) { + if (!warned.insertLeft) { + console.warn( + 'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead', + ); + warned.insertLeft = true; + } + + return this.appendLeft(index, content); + } + + insertRight(index, content) { + if (!warned.insertRight) { + console.warn( + 'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead', + ); + warned.insertRight = true; + } + + return this.prependRight(index, content); + } + + move(start, end, index) { + start = start + this.offset; + end = end + this.offset; + index = index + this.offset; + + if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself'); + + this._split(start); + this._split(end); + this._split(index); + + const first = this.byStart[start]; + const last = this.byEnd[end]; + + const oldLeft = first.previous; + const oldRight = last.next; + + const newRight = this.byStart[index]; + if (!newRight && last === this.lastChunk) return this; + const newLeft = newRight ? newRight.previous : this.lastChunk; + + if (oldLeft) oldLeft.next = oldRight; + if (oldRight) oldRight.previous = oldLeft; + + if (newLeft) newLeft.next = first; + if (newRight) newRight.previous = last; + + if (!first.previous) this.firstChunk = last.next; + if (!last.next) { + this.lastChunk = first.previous; + this.lastChunk.next = null; + } + + first.previous = newLeft; + last.next = newRight || null; + + if (!newLeft) this.firstChunk = first; + if (!newRight) this.lastChunk = last; + return this; + } + + overwrite(start, end, content, options) { + options = options || {}; + return this.update(start, end, content, { ...options, overwrite: !options.contentOnly }); + } + + update(start, end, content, options) { + start = start + this.offset; + end = end + this.offset; + + if (typeof content !== 'string') throw new TypeError('replacement content must be a string'); + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + if (end > this.original.length) throw new Error('end is out of bounds'); + if (start === end) + throw new Error( + 'Cannot overwrite a zero-length range – use appendLeft or prependRight instead', + ); + + this._split(start); + this._split(end); + + if (options === true) { + if (!warned.storeName) { + console.warn( + 'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string', + ); + warned.storeName = true; + } + + options = { storeName: true }; + } + const storeName = options !== undefined ? options.storeName : false; + const overwrite = options !== undefined ? options.overwrite : false; + + if (storeName) { + const original = this.original.slice(start, end); + Object.defineProperty(this.storedNames, original, { + writable: true, + value: true, + enumerable: true, + }); + } + + const first = this.byStart[start]; + const last = this.byEnd[end]; + + if (first) { + let chunk = first; + while (chunk !== last) { + if (chunk.next !== this.byStart[chunk.end]) { + throw new Error('Cannot overwrite across a split point'); + } + chunk = chunk.next; + chunk.edit('', false); + } + + first.edit(content, storeName, !overwrite); + } else { + // must be inserting at the end + const newChunk = new Chunk(start, end, '').edit(content, storeName); + + // TODO last chunk in the array may not be the last chunk, if it's moved... + last.next = newChunk; + newChunk.previous = last; + } + return this; + } + + prepend(content) { + if (typeof content !== 'string') throw new TypeError('outro content must be a string'); + + this.intro = content + this.intro; + return this; + } + + prependLeft(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byEnd[index]; + + if (chunk) { + chunk.prependLeft(content); + } else { + this.intro = content + this.intro; + } + return this; + } + + prependRight(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byStart[index]; + + if (chunk) { + chunk.prependRight(content); + } else { + this.outro = content + this.outro; + } + return this; + } + + remove(start, end) { + start = start + this.offset; + end = end + this.offset; + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + if (start === end) return this; + + if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds'); + if (start > end) throw new Error('end must be greater than start'); + + this._split(start); + this._split(end); + + let chunk = this.byStart[start]; + + while (chunk) { + chunk.intro = ''; + chunk.outro = ''; + chunk.edit(''); + + chunk = end > chunk.end ? this.byStart[chunk.end] : null; + } + return this; + } + + reset(start, end) { + start = start + this.offset; + end = end + this.offset; + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + if (start === end) return this; + + if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds'); + if (start > end) throw new Error('end must be greater than start'); + + this._split(start); + this._split(end); + + let chunk = this.byStart[start]; + + while (chunk) { + chunk.reset(); + + chunk = end > chunk.end ? this.byStart[chunk.end] : null; + } + return this; + } + + lastChar() { + if (this.outro.length) return this.outro[this.outro.length - 1]; + let chunk = this.lastChunk; + do { + if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1]; + if (chunk.content.length) return chunk.content[chunk.content.length - 1]; + if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1]; + } while ((chunk = chunk.previous)); + if (this.intro.length) return this.intro[this.intro.length - 1]; + return ''; + } + + lastLine() { + let lineIndex = this.outro.lastIndexOf(n); + if (lineIndex !== -1) return this.outro.substr(lineIndex + 1); + let lineStr = this.outro; + let chunk = this.lastChunk; + do { + if (chunk.outro.length > 0) { + lineIndex = chunk.outro.lastIndexOf(n); + if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr; + lineStr = chunk.outro + lineStr; + } + + if (chunk.content.length > 0) { + lineIndex = chunk.content.lastIndexOf(n); + if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr; + lineStr = chunk.content + lineStr; + } + + if (chunk.intro.length > 0) { + lineIndex = chunk.intro.lastIndexOf(n); + if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr; + lineStr = chunk.intro + lineStr; + } + } while ((chunk = chunk.previous)); + lineIndex = this.intro.lastIndexOf(n); + if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr; + return this.intro + lineStr; + } + + slice(start = 0, end = this.original.length - this.offset) { + start = start + this.offset; + end = end + this.offset; + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + let result = ''; + + // find start chunk + let chunk = this.firstChunk; + while (chunk && (chunk.start > start || chunk.end <= start)) { + // found end chunk before start + if (chunk.start < end && chunk.end >= end) { + return result; + } + + chunk = chunk.next; + } + + if (chunk && chunk.edited && chunk.start !== start) + throw new Error(`Cannot use replaced character ${start} as slice start anchor.`); + + const startChunk = chunk; + while (chunk) { + if (chunk.intro && (startChunk !== chunk || chunk.start === start)) { + result += chunk.intro; + } + + const containsEnd = chunk.start < end && chunk.end >= end; + if (containsEnd && chunk.edited && chunk.end !== end) + throw new Error(`Cannot use replaced character ${end} as slice end anchor.`); + + const sliceStart = startChunk === chunk ? start - chunk.start : 0; + const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length; + + result += chunk.content.slice(sliceStart, sliceEnd); + + if (chunk.outro && (!containsEnd || chunk.end === end)) { + result += chunk.outro; + } + + if (containsEnd) { + break; + } + + chunk = chunk.next; + } + + return result; + } + + // TODO deprecate this? not really very useful + snip(start, end) { + const clone = this.clone(); + clone.remove(0, start); + clone.remove(end, clone.original.length); + + return clone; + } + + _split(index) { + if (this.byStart[index] || this.byEnd[index]) return; + + let chunk = this.lastSearchedChunk; + let previousChunk = chunk; + const searchForward = index > chunk.end; + + while (chunk) { + if (chunk.contains(index)) return this._splitChunk(chunk, index); + + chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start]; + + // Prevent infinite loop (e.g. via empty chunks, where start === end) + if (chunk === previousChunk) return; + + previousChunk = chunk; + } + } + + _splitChunk(chunk, index) { + if (chunk.edited && chunk.content.length) { + // zero-length edited chunks are a special case (overlapping replacements) + const loc = getLocator(this.original)(index); + throw new Error( + `Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`, + ); + } + + const newChunk = chunk.split(index); + + this.byEnd[index] = chunk; + this.byStart[index] = newChunk; + this.byEnd[newChunk.end] = newChunk; + + if (chunk === this.lastChunk) this.lastChunk = newChunk; + + this.lastSearchedChunk = chunk; + return true; + } + + toString() { + let str = this.intro; + + let chunk = this.firstChunk; + while (chunk) { + str += chunk.toString(); + chunk = chunk.next; + } + + return str + this.outro; + } + + isEmpty() { + let chunk = this.firstChunk; + do { + if ( + (chunk.intro.length && chunk.intro.trim()) || + (chunk.content.length && chunk.content.trim()) || + (chunk.outro.length && chunk.outro.trim()) + ) + return false; + } while ((chunk = chunk.next)); + return true; + } + + length() { + let chunk = this.firstChunk; + let length = 0; + do { + length += chunk.intro.length + chunk.content.length + chunk.outro.length; + } while ((chunk = chunk.next)); + return length; + } + + trimLines() { + return this.trim('[\\r\\n]'); + } + + trim(charType) { + return this.trimStart(charType).trimEnd(charType); + } + + trimEndAborted(charType) { + const rx = new RegExp((charType || '\\s') + '+$'); + + this.outro = this.outro.replace(rx, ''); + if (this.outro.length) return true; + + let chunk = this.lastChunk; + + do { + const end = chunk.end; + const aborted = chunk.trimEnd(rx); + + // if chunk was trimmed, we have a new lastChunk + if (chunk.end !== end) { + if (this.lastChunk === chunk) { + this.lastChunk = chunk.next; + } + + this.byEnd[chunk.end] = chunk; + this.byStart[chunk.next.start] = chunk.next; + this.byEnd[chunk.next.end] = chunk.next; + } + + if (aborted) return true; + chunk = chunk.previous; + } while (chunk); + + return false; + } + + trimEnd(charType) { + this.trimEndAborted(charType); + return this; + } + trimStartAborted(charType) { + const rx = new RegExp('^' + (charType || '\\s') + '+'); + + this.intro = this.intro.replace(rx, ''); + if (this.intro.length) return true; + + let chunk = this.firstChunk; + + do { + const end = chunk.end; + const aborted = chunk.trimStart(rx); + + if (chunk.end !== end) { + // special case... + if (chunk === this.lastChunk) this.lastChunk = chunk.next; + + this.byEnd[chunk.end] = chunk; + this.byStart[chunk.next.start] = chunk.next; + this.byEnd[chunk.next.end] = chunk.next; + } + + if (aborted) return true; + chunk = chunk.next; + } while (chunk); + + return false; + } + + trimStart(charType) { + this.trimStartAborted(charType); + return this; + } + + hasChanged() { + return this.original !== this.toString(); + } + + _replaceRegexp(searchValue, replacement) { + function getReplacement(match, str) { + if (typeof replacement === 'string') { + return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => { + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter + if (i === '$') return '$'; + if (i === '&') return match[0]; + const num = +i; + if (num < match.length) return match[+i]; + return `$${i}`; + }); + } else { + return replacement(...match, match.index, str, match.groups); + } + } + function matchAll(re, str) { + let match; + const matches = []; + while ((match = re.exec(str))) { + matches.push(match); + } + return matches; + } + if (searchValue.global) { + const matches = matchAll(searchValue, this.original); + matches.forEach((match) => { + if (match.index != null) { + const replacement = getReplacement(match, this.original); + if (replacement !== match[0]) { + this.overwrite(match.index, match.index + match[0].length, replacement); + } + } + }); + } else { + const match = this.original.match(searchValue); + if (match && match.index != null) { + const replacement = getReplacement(match, this.original); + if (replacement !== match[0]) { + this.overwrite(match.index, match.index + match[0].length, replacement); + } + } + } + return this; + } + + _replaceString(string, replacement) { + const { original } = this; + const index = original.indexOf(string); + + if (index !== -1) { + if (typeof replacement === 'function') { + replacement = replacement(string, index, original); + } + if (string !== replacement) { + this.overwrite(index, index + string.length, replacement); + } + } + + return this; + } + + replace(searchValue, replacement) { + if (typeof searchValue === 'string') { + return this._replaceString(searchValue, replacement); + } + + return this._replaceRegexp(searchValue, replacement); + } + + _replaceAllString(string, replacement) { + const { original } = this; + const stringLength = string.length; + for ( + let index = original.indexOf(string); + index !== -1; + index = original.indexOf(string, index + stringLength) + ) { + const previous = original.slice(index, index + stringLength); + let _replacement = replacement; + if (typeof replacement === 'function') { + _replacement = replacement(previous, index, original); + } + if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement); + } + + return this; + } + + replaceAll(searchValue, replacement) { + if (typeof searchValue === 'string') { + return this._replaceAllString(searchValue, replacement); + } + + if (!searchValue.global) { + throw new TypeError( + 'MagicString.prototype.replaceAll called with a non-global RegExp argument', + ); + } + + return this._replaceRegexp(searchValue, replacement); + } +} + +const hasOwnProp = Object.prototype.hasOwnProperty; + +class Bundle { + constructor(options = {}) { + this.intro = options.intro || ''; + this.separator = options.separator !== undefined ? options.separator : '\n'; + this.sources = []; + this.uniqueSources = []; + this.uniqueSourceIndexByFilename = {}; + } + + addSource(source) { + if (source instanceof MagicString) { + return this.addSource({ + content: source, + filename: source.filename, + separator: this.separator, + }); + } + + if (!isObject(source) || !source.content) { + throw new Error( + 'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`', + ); + } + + ['filename', 'ignoreList', 'indentExclusionRanges', 'separator'].forEach((option) => { + if (!hasOwnProp.call(source, option)) source[option] = source.content[option]; + }); + + if (source.separator === undefined) { + // TODO there's a bunch of this sort of thing, needs cleaning up + source.separator = this.separator; + } + + if (source.filename) { + if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) { + this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length; + this.uniqueSources.push({ filename: source.filename, content: source.content.original }); + } else { + const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]]; + if (source.content.original !== uniqueSource.content) { + throw new Error(`Illegal source: same filename (${source.filename}), different contents`); + } + } + } + + this.sources.push(source); + return this; + } + + append(str, options) { + this.addSource({ + content: new MagicString(str), + separator: (options && options.separator) || '', + }); + + return this; + } + + clone() { + const bundle = new Bundle({ + intro: this.intro, + separator: this.separator, + }); + + this.sources.forEach((source) => { + bundle.addSource({ + filename: source.filename, + content: source.content.clone(), + separator: source.separator, + }); + }); + + return bundle; + } + + generateDecodedMap(options = {}) { + const names = []; + let x_google_ignoreList = undefined; + this.sources.forEach((source) => { + Object.keys(source.content.storedNames).forEach((name) => { + if (!~names.indexOf(name)) names.push(name); + }); + }); + + const mappings = new Mappings(options.hires); + + if (this.intro) { + mappings.advance(this.intro); + } + + this.sources.forEach((source, i) => { + if (i > 0) { + mappings.advance(this.separator); + } + + const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1; + const magicString = source.content; + const locate = getLocator(magicString.original); + + if (magicString.intro) { + mappings.advance(magicString.intro); + } + + magicString.firstChunk.eachNext((chunk) => { + const loc = locate(chunk.start); + + if (chunk.intro.length) mappings.advance(chunk.intro); + + if (source.filename) { + if (chunk.edited) { + mappings.addEdit( + sourceIndex, + chunk.content, + loc, + chunk.storeName ? names.indexOf(chunk.original) : -1, + ); + } else { + mappings.addUneditedChunk( + sourceIndex, + chunk, + magicString.original, + loc, + magicString.sourcemapLocations, + ); + } + } else { + mappings.advance(chunk.content); + } + + if (chunk.outro.length) mappings.advance(chunk.outro); + }); + + if (magicString.outro) { + mappings.advance(magicString.outro); + } + + if (source.ignoreList && sourceIndex !== -1) { + if (x_google_ignoreList === undefined) { + x_google_ignoreList = []; + } + x_google_ignoreList.push(sourceIndex); + } + }); + + return { + file: options.file ? options.file.split(/[/\\]/).pop() : undefined, + sources: this.uniqueSources.map((source) => { + return options.file ? getRelativePath(options.file, source.filename) : source.filename; + }), + sourcesContent: this.uniqueSources.map((source) => { + return options.includeContent ? source.content : null; + }), + names, + mappings: mappings.raw, + x_google_ignoreList, + }; + } + + generateMap(options) { + return new SourceMap(this.generateDecodedMap(options)); + } + + getIndentString() { + const indentStringCounts = {}; + + this.sources.forEach((source) => { + const indentStr = source.content._getRawIndentString(); + + if (indentStr === null) return; + + if (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0; + indentStringCounts[indentStr] += 1; + }); + + return ( + Object.keys(indentStringCounts).sort((a, b) => { + return indentStringCounts[a] - indentStringCounts[b]; + })[0] || '\t' + ); + } + + indent(indentStr) { + if (!arguments.length) { + indentStr = this.getIndentString(); + } + + if (indentStr === '') return this; // noop + + let trailingNewline = !this.intro || this.intro.slice(-1) === '\n'; + + this.sources.forEach((source, i) => { + const separator = source.separator !== undefined ? source.separator : this.separator; + const indentStart = trailingNewline || (i > 0 && /\r?\n$/.test(separator)); + + source.content.indent(indentStr, { + exclude: source.indentExclusionRanges, + indentStart, //: trailingNewline || /\r?\n$/.test( separator ) //true///\r?\n/.test( separator ) + }); + + trailingNewline = source.content.lastChar() === '\n'; + }); + + if (this.intro) { + this.intro = + indentStr + + this.intro.replace(/^[^\n]/gm, (match, index) => { + return index > 0 ? indentStr + match : match; + }); + } + + return this; + } + + prepend(str) { + this.intro = str + this.intro; + return this; + } + + toString() { + const body = this.sources + .map((source, i) => { + const separator = source.separator !== undefined ? source.separator : this.separator; + const str = (i > 0 ? separator : '') + source.content.toString(); + + return str; + }) + .join(''); + + return this.intro + body; + } + + isEmpty() { + if (this.intro.length && this.intro.trim()) return false; + if (this.sources.some((source) => !source.content.isEmpty())) return false; + return true; + } + + length() { + return this.sources.reduce( + (length, source) => length + source.content.length(), + this.intro.length, + ); + } + + trimLines() { + return this.trim('[\\r\\n]'); + } + + trim(charType) { + return this.trimStart(charType).trimEnd(charType); + } + + trimStart(charType) { + const rx = new RegExp('^' + (charType || '\\s') + '+'); + this.intro = this.intro.replace(rx, ''); + + if (!this.intro) { + let source; + let i = 0; + + do { + source = this.sources[i++]; + if (!source) { + break; + } + } while (!source.content.trimStartAborted(charType)); + } + + return this; + } + + trimEnd(charType) { + const rx = new RegExp((charType || '\\s') + '+$'); + + let source; + let i = this.sources.length - 1; + + do { + source = this.sources[i--]; + if (!source) { + this.intro = this.intro.replace(rx, ''); + break; + } + } while (!source.content.trimEndAborted(charType)); + + return this; + } +} + +MagicString.Bundle = Bundle; +MagicString.SourceMap = SourceMap; +MagicString.default = MagicString; // work around TypeScript bug https://github.com/Rich-Harris/magic-string/pull/121 + +module.exports = MagicString; +//# sourceMappingURL=magic-string.cjs.js.map diff --git a/frontend/node_modules/magic-string/dist/magic-string.cjs.js.map b/frontend/node_modules/magic-string/dist/magic-string.cjs.js.map new file mode 100644 index 0000000..685274f --- /dev/null +++ b/frontend/node_modules/magic-string/dist/magic-string.cjs.js.map @@ -0,0 +1 @@ +{"version":3,"file":"magic-string.cjs.js","sources":["../src/BitSet.js","../src/Chunk.js","../src/SourceMap.js","../src/utils/guessIndent.js","../src/utils/getRelativePath.js","../src/utils/isObject.js","../src/utils/getLocator.js","../src/utils/Mappings.js","../src/MagicString.js","../src/Bundle.js","../src/index-legacy.js"],"sourcesContent":["export default class BitSet {\n\tconstructor(arg) {\n\t\tthis.bits = arg instanceof BitSet ? arg.bits.slice() : [];\n\t}\n\n\tadd(n) {\n\t\tthis.bits[n >> 5] |= 1 << (n & 31);\n\t}\n\n\thas(n) {\n\t\treturn !!(this.bits[n >> 5] & (1 << (n & 31)));\n\t}\n}\n","export default class Chunk {\n\tconstructor(start, end, content) {\n\t\tthis.start = start;\n\t\tthis.end = end;\n\t\tthis.original = content;\n\n\t\tthis.intro = '';\n\t\tthis.outro = '';\n\n\t\tthis.content = content;\n\t\tthis.storeName = false;\n\t\tthis.edited = false;\n\n\t\tif (DEBUG) {\n\t\t\t// we make these non-enumerable, for sanity while debugging\n\t\t\tObject.defineProperties(this, {\n\t\t\t\tprevious: { writable: true, value: null },\n\t\t\t\tnext: { writable: true, value: null },\n\t\t\t});\n\t\t} else {\n\t\t\tthis.previous = null;\n\t\t\tthis.next = null;\n\t\t}\n\t}\n\n\tappendLeft(content) {\n\t\tthis.outro += content;\n\t}\n\n\tappendRight(content) {\n\t\tthis.intro = this.intro + content;\n\t}\n\n\tclone() {\n\t\tconst chunk = new Chunk(this.start, this.end, this.original);\n\n\t\tchunk.intro = this.intro;\n\t\tchunk.outro = this.outro;\n\t\tchunk.content = this.content;\n\t\tchunk.storeName = this.storeName;\n\t\tchunk.edited = this.edited;\n\n\t\treturn chunk;\n\t}\n\n\tcontains(index) {\n\t\treturn this.start < index && index < this.end;\n\t}\n\n\teachNext(fn) {\n\t\tlet chunk = this;\n\t\twhile (chunk) {\n\t\t\tfn(chunk);\n\t\t\tchunk = chunk.next;\n\t\t}\n\t}\n\n\teachPrevious(fn) {\n\t\tlet chunk = this;\n\t\twhile (chunk) {\n\t\t\tfn(chunk);\n\t\t\tchunk = chunk.previous;\n\t\t}\n\t}\n\n\tedit(content, storeName, contentOnly) {\n\t\tthis.content = content;\n\t\tif (!contentOnly) {\n\t\t\tthis.intro = '';\n\t\t\tthis.outro = '';\n\t\t}\n\t\tthis.storeName = storeName;\n\n\t\tthis.edited = true;\n\n\t\treturn this;\n\t}\n\n\tprependLeft(content) {\n\t\tthis.outro = content + this.outro;\n\t}\n\n\tprependRight(content) {\n\t\tthis.intro = content + this.intro;\n\t}\n\n\treset() {\n\t\tthis.intro = '';\n\t\tthis.outro = '';\n\t\tif (this.edited) {\n\t\t\tthis.content = this.original;\n\t\t\tthis.storeName = false;\n\t\t\tthis.edited = false;\n\t\t}\n\t}\n\n\tsplit(index) {\n\t\tconst sliceIndex = index - this.start;\n\n\t\tconst originalBefore = this.original.slice(0, sliceIndex);\n\t\tconst originalAfter = this.original.slice(sliceIndex);\n\n\t\tthis.original = originalBefore;\n\n\t\tconst newChunk = new Chunk(index, this.end, originalAfter);\n\t\tnewChunk.outro = this.outro;\n\t\tthis.outro = '';\n\n\t\tthis.end = index;\n\n\t\tif (this.edited) {\n\t\t\t// after split we should save the edit content record into the correct chunk\n\t\t\t// to make sure sourcemap correct\n\t\t\t// For example:\n\t\t\t// ' test'.trim()\n\t\t\t// split -> ' ' + 'test'\n\t\t\t// ✔️ edit -> '' + 'test'\n\t\t\t// ✖️ edit -> 'test' + ''\n\t\t\t// TODO is this block necessary?...\n\t\t\tnewChunk.edit('', false);\n\t\t\tthis.content = '';\n\t\t} else {\n\t\t\tthis.content = originalBefore;\n\t\t}\n\n\t\tnewChunk.next = this.next;\n\t\tif (newChunk.next) newChunk.next.previous = newChunk;\n\t\tnewChunk.previous = this;\n\t\tthis.next = newChunk;\n\n\t\treturn newChunk;\n\t}\n\n\ttoString() {\n\t\treturn this.intro + this.content + this.outro;\n\t}\n\n\ttrimEnd(rx) {\n\t\tthis.outro = this.outro.replace(rx, '');\n\t\tif (this.outro.length) return true;\n\n\t\tconst trimmed = this.content.replace(rx, '');\n\n\t\tif (trimmed.length) {\n\t\t\tif (trimmed !== this.content) {\n\t\t\t\tthis.split(this.start + trimmed.length).edit('', undefined, true);\n\t\t\t\tif (this.edited) {\n\t\t\t\t\t// save the change, if it has been edited\n\t\t\t\t\tthis.edit(trimmed, this.storeName, true);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} else {\n\t\t\tthis.edit('', undefined, true);\n\n\t\t\tthis.intro = this.intro.replace(rx, '');\n\t\t\tif (this.intro.length) return true;\n\t\t}\n\t}\n\n\ttrimStart(rx) {\n\t\tthis.intro = this.intro.replace(rx, '');\n\t\tif (this.intro.length) return true;\n\n\t\tconst trimmed = this.content.replace(rx, '');\n\n\t\tif (trimmed.length) {\n\t\t\tif (trimmed !== this.content) {\n\t\t\t\tconst newChunk = this.split(this.end - trimmed.length);\n\t\t\t\tif (this.edited) {\n\t\t\t\t\t// save the change, if it has been edited\n\t\t\t\t\tnewChunk.edit(trimmed, this.storeName, true);\n\t\t\t\t}\n\t\t\t\tthis.edit('', undefined, true);\n\t\t\t}\n\t\t\treturn true;\n\t\t} else {\n\t\t\tthis.edit('', undefined, true);\n\n\t\t\tthis.outro = this.outro.replace(rx, '');\n\t\t\tif (this.outro.length) return true;\n\t\t}\n\t}\n}\n","import { encode } from '@jridgewell/sourcemap-codec';\n\nfunction getBtoa() {\n\tif (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {\n\t\treturn (str) => globalThis.btoa(unescape(encodeURIComponent(str)));\n\t} else if (typeof Buffer === 'function') {\n\t\treturn (str) => Buffer.from(str, 'utf-8').toString('base64');\n\t} else {\n\t\treturn () => {\n\t\t\tthrow new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');\n\t\t};\n\t}\n}\n\nconst btoa = /*#__PURE__*/ getBtoa();\n\nexport default class SourceMap {\n\tconstructor(properties) {\n\t\tthis.version = 3;\n\t\tthis.file = properties.file;\n\t\tthis.sources = properties.sources;\n\t\tthis.sourcesContent = properties.sourcesContent;\n\t\tthis.names = properties.names;\n\t\tthis.mappings = encode(properties.mappings);\n\t\tif (typeof properties.x_google_ignoreList !== 'undefined') {\n\t\t\tthis.x_google_ignoreList = properties.x_google_ignoreList;\n\t\t}\n\t\tif (typeof properties.debugId !== 'undefined') {\n\t\t\tthis.debugId = properties.debugId;\n\t\t}\n\t}\n\n\ttoString() {\n\t\treturn JSON.stringify(this);\n\t}\n\n\ttoUrl() {\n\t\treturn 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());\n\t}\n}\n","export default function guessIndent(code) {\n\tconst lines = code.split('\\n');\n\n\tconst tabbed = lines.filter((line) => /^\\t+/.test(line));\n\tconst spaced = lines.filter((line) => /^ {2,}/.test(line));\n\n\tif (tabbed.length === 0 && spaced.length === 0) {\n\t\treturn null;\n\t}\n\n\t// More lines tabbed than spaced? Assume tabs, and\n\t// default to tabs in the case of a tie (or nothing\n\t// to go on)\n\tif (tabbed.length >= spaced.length) {\n\t\treturn '\\t';\n\t}\n\n\t// Otherwise, we need to guess the multiple\n\tconst min = spaced.reduce((previous, current) => {\n\t\tconst numSpaces = /^ +/.exec(current)[0].length;\n\t\treturn Math.min(numSpaces, previous);\n\t}, Infinity);\n\n\treturn new Array(min + 1).join(' ');\n}\n","export default function getRelativePath(from, to) {\n\tconst fromParts = from.split(/[/\\\\]/);\n\tconst toParts = to.split(/[/\\\\]/);\n\n\tfromParts.pop(); // get dirname\n\n\twhile (fromParts[0] === toParts[0]) {\n\t\tfromParts.shift();\n\t\ttoParts.shift();\n\t}\n\n\tif (fromParts.length) {\n\t\tlet i = fromParts.length;\n\t\twhile (i--) fromParts[i] = '..';\n\t}\n\n\treturn fromParts.concat(toParts).join('/');\n}\n","const toString = Object.prototype.toString;\n\nexport default function isObject(thing) {\n\treturn toString.call(thing) === '[object Object]';\n}\n","export default function getLocator(source) {\n\tconst originalLines = source.split('\\n');\n\tconst lineOffsets = [];\n\n\tfor (let i = 0, pos = 0; i < originalLines.length; i++) {\n\t\tlineOffsets.push(pos);\n\t\tpos += originalLines[i].length + 1;\n\t}\n\n\treturn function locate(index) {\n\t\tlet i = 0;\n\t\tlet j = lineOffsets.length;\n\t\twhile (i < j) {\n\t\t\tconst m = (i + j) >> 1;\n\t\t\tif (index < lineOffsets[m]) {\n\t\t\t\tj = m;\n\t\t\t} else {\n\t\t\t\ti = m + 1;\n\t\t\t}\n\t\t}\n\t\tconst line = i - 1;\n\t\tconst column = index - lineOffsets[line];\n\t\treturn { line, column };\n\t};\n}\n","const wordRegex = /\\w/;\n\nexport default class Mappings {\n\tconstructor(hires) {\n\t\tthis.hires = hires;\n\t\tthis.generatedCodeLine = 0;\n\t\tthis.generatedCodeColumn = 0;\n\t\tthis.raw = [];\n\t\tthis.rawSegments = this.raw[this.generatedCodeLine] = [];\n\t\tthis.pending = null;\n\t}\n\n\taddEdit(sourceIndex, content, loc, nameIndex) {\n\t\tif (content.length) {\n\t\t\tconst contentLengthMinusOne = content.length - 1;\n\t\t\tlet contentLineEnd = content.indexOf('\\n', 0);\n\t\t\tlet previousContentLineEnd = -1;\n\t\t\t// Loop through each line in the content and add a segment, but stop if the last line is empty,\n\t\t\t// else code afterwards would fill one line too many\n\t\t\twhile (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {\n\t\t\t\tconst segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];\n\t\t\t\tif (nameIndex >= 0) {\n\t\t\t\t\tsegment.push(nameIndex);\n\t\t\t\t}\n\t\t\t\tthis.rawSegments.push(segment);\n\n\t\t\t\tthis.generatedCodeLine += 1;\n\t\t\t\tthis.raw[this.generatedCodeLine] = this.rawSegments = [];\n\t\t\t\tthis.generatedCodeColumn = 0;\n\n\t\t\t\tpreviousContentLineEnd = contentLineEnd;\n\t\t\t\tcontentLineEnd = content.indexOf('\\n', contentLineEnd + 1);\n\t\t\t}\n\n\t\t\tconst segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];\n\t\t\tif (nameIndex >= 0) {\n\t\t\t\tsegment.push(nameIndex);\n\t\t\t}\n\t\t\tthis.rawSegments.push(segment);\n\n\t\t\tthis.advance(content.slice(previousContentLineEnd + 1));\n\t\t} else if (this.pending) {\n\t\t\tthis.rawSegments.push(this.pending);\n\t\t\tthis.advance(content);\n\t\t}\n\n\t\tthis.pending = null;\n\t}\n\n\taddUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {\n\t\tlet originalCharIndex = chunk.start;\n\t\tlet first = true;\n\t\t// when iterating each char, check if it's in a word boundary\n\t\tlet charInHiresBoundary = false;\n\n\t\twhile (originalCharIndex < chunk.end) {\n\t\t\tif (original[originalCharIndex] === '\\n') {\n\t\t\t\tloc.line += 1;\n\t\t\t\tloc.column = 0;\n\t\t\t\tthis.generatedCodeLine += 1;\n\t\t\t\tthis.raw[this.generatedCodeLine] = this.rawSegments = [];\n\t\t\t\tthis.generatedCodeColumn = 0;\n\t\t\t\tfirst = true;\n\t\t\t\tcharInHiresBoundary = false;\n\t\t\t} else {\n\t\t\t\tif (this.hires || first || sourcemapLocations.has(originalCharIndex)) {\n\t\t\t\t\tconst segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];\n\n\t\t\t\t\tif (this.hires === 'boundary') {\n\t\t\t\t\t\t// in hires \"boundary\", group segments per word boundary than per char\n\t\t\t\t\t\tif (wordRegex.test(original[originalCharIndex])) {\n\t\t\t\t\t\t\t// for first char in the boundary found, start the boundary by pushing a segment\n\t\t\t\t\t\t\tif (!charInHiresBoundary) {\n\t\t\t\t\t\t\t\tthis.rawSegments.push(segment);\n\t\t\t\t\t\t\t\tcharInHiresBoundary = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// for non-word char, end the boundary by pushing a segment\n\t\t\t\t\t\t\tthis.rawSegments.push(segment);\n\t\t\t\t\t\t\tcharInHiresBoundary = false;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.rawSegments.push(segment);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tloc.column += 1;\n\t\t\t\tthis.generatedCodeColumn += 1;\n\t\t\t\tfirst = false;\n\t\t\t}\n\n\t\t\toriginalCharIndex += 1;\n\t\t}\n\n\t\tthis.pending = null;\n\t}\n\n\tadvance(str) {\n\t\tif (!str) return;\n\n\t\tconst lines = str.split('\\n');\n\n\t\tif (lines.length > 1) {\n\t\t\tfor (let i = 0; i < lines.length - 1; i++) {\n\t\t\t\tthis.generatedCodeLine++;\n\t\t\t\tthis.raw[this.generatedCodeLine] = this.rawSegments = [];\n\t\t\t}\n\t\t\tthis.generatedCodeColumn = 0;\n\t\t}\n\n\t\tthis.generatedCodeColumn += lines[lines.length - 1].length;\n\t}\n}\n","import BitSet from './BitSet.js';\nimport Chunk from './Chunk.js';\nimport SourceMap from './SourceMap.js';\nimport guessIndent from './utils/guessIndent.js';\nimport getRelativePath from './utils/getRelativePath.js';\nimport isObject from './utils/isObject.js';\nimport getLocator from './utils/getLocator.js';\nimport Mappings from './utils/Mappings.js';\nimport Stats from './utils/Stats.js';\n\nconst n = '\\n';\n\nconst warned = {\n\tinsertLeft: false,\n\tinsertRight: false,\n\tstoreName: false,\n};\n\nexport default class MagicString {\n\tconstructor(string, options = {}) {\n\t\tconst chunk = new Chunk(0, string.length, string);\n\n\t\tObject.defineProperties(this, {\n\t\t\toriginal: { writable: true, value: string },\n\t\t\toutro: { writable: true, value: '' },\n\t\t\tintro: { writable: true, value: '' },\n\t\t\tfirstChunk: { writable: true, value: chunk },\n\t\t\tlastChunk: { writable: true, value: chunk },\n\t\t\tlastSearchedChunk: { writable: true, value: chunk },\n\t\t\tbyStart: { writable: true, value: {} },\n\t\t\tbyEnd: { writable: true, value: {} },\n\t\t\tfilename: { writable: true, value: options.filename },\n\t\t\tindentExclusionRanges: { writable: true, value: options.indentExclusionRanges },\n\t\t\tsourcemapLocations: { writable: true, value: new BitSet() },\n\t\t\tstoredNames: { writable: true, value: {} },\n\t\t\tindentStr: { writable: true, value: undefined },\n\t\t\tignoreList: { writable: true, value: options.ignoreList },\n\t\t\toffset: { writable: true, value: options.offset || 0 },\n\t\t});\n\n\t\tif (DEBUG) {\n\t\t\tObject.defineProperty(this, 'stats', { value: new Stats() });\n\t\t}\n\n\t\tthis.byStart[0] = chunk;\n\t\tthis.byEnd[string.length] = chunk;\n\t}\n\n\taddSourcemapLocation(char) {\n\t\tthis.sourcemapLocations.add(char);\n\t}\n\n\tappend(content) {\n\t\tif (typeof content !== 'string') throw new TypeError('outro content must be a string');\n\n\t\tthis.outro += content;\n\t\treturn this;\n\t}\n\n\tappendLeft(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('appendLeft');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byEnd[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.appendLeft(content);\n\t\t} else {\n\t\t\tthis.intro += content;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('appendLeft');\n\t\treturn this;\n\t}\n\n\tappendRight(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('appendRight');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byStart[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.appendRight(content);\n\t\t} else {\n\t\t\tthis.outro += content;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('appendRight');\n\t\treturn this;\n\t}\n\n\tclone() {\n\t\tconst cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset });\n\n\t\tlet originalChunk = this.firstChunk;\n\t\tlet clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());\n\n\t\twhile (originalChunk) {\n\t\t\tcloned.byStart[clonedChunk.start] = clonedChunk;\n\t\t\tcloned.byEnd[clonedChunk.end] = clonedChunk;\n\n\t\t\tconst nextOriginalChunk = originalChunk.next;\n\t\t\tconst nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();\n\n\t\t\tif (nextClonedChunk) {\n\t\t\t\tclonedChunk.next = nextClonedChunk;\n\t\t\t\tnextClonedChunk.previous = clonedChunk;\n\n\t\t\t\tclonedChunk = nextClonedChunk;\n\t\t\t}\n\n\t\t\toriginalChunk = nextOriginalChunk;\n\t\t}\n\n\t\tcloned.lastChunk = clonedChunk;\n\n\t\tif (this.indentExclusionRanges) {\n\t\t\tcloned.indentExclusionRanges = this.indentExclusionRanges.slice();\n\t\t}\n\n\t\tcloned.sourcemapLocations = new BitSet(this.sourcemapLocations);\n\n\t\tcloned.intro = this.intro;\n\t\tcloned.outro = this.outro;\n\n\t\treturn cloned;\n\t}\n\n\tgenerateDecodedMap(options) {\n\t\toptions = options || {};\n\n\t\tconst sourceIndex = 0;\n\t\tconst names = Object.keys(this.storedNames);\n\t\tconst mappings = new Mappings(options.hires);\n\n\t\tconst locate = getLocator(this.original);\n\n\t\tif (this.intro) {\n\t\t\tmappings.advance(this.intro);\n\t\t}\n\n\t\tthis.firstChunk.eachNext((chunk) => {\n\t\t\tconst loc = locate(chunk.start);\n\n\t\t\tif (chunk.intro.length) mappings.advance(chunk.intro);\n\n\t\t\tif (chunk.edited) {\n\t\t\t\tmappings.addEdit(\n\t\t\t\t\tsourceIndex,\n\t\t\t\t\tchunk.content,\n\t\t\t\t\tloc,\n\t\t\t\t\tchunk.storeName ? names.indexOf(chunk.original) : -1,\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tmappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);\n\t\t\t}\n\n\t\t\tif (chunk.outro.length) mappings.advance(chunk.outro);\n\t\t});\n\n\t\tif (this.outro) {\n\t\t\tmappings.advance(this.outro);\n\t\t}\n\n\t\treturn {\n\t\t\tfile: options.file ? options.file.split(/[/\\\\]/).pop() : undefined,\n\t\t\tsources: [\n\t\t\t\toptions.source ? getRelativePath(options.file || '', options.source) : options.file || '',\n\t\t\t],\n\t\t\tsourcesContent: options.includeContent ? [this.original] : undefined,\n\t\t\tnames,\n\t\t\tmappings: mappings.raw,\n\t\t\tx_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,\n\t\t};\n\t}\n\n\tgenerateMap(options) {\n\t\treturn new SourceMap(this.generateDecodedMap(options));\n\t}\n\n\t_ensureindentStr() {\n\t\tif (this.indentStr === undefined) {\n\t\t\tthis.indentStr = guessIndent(this.original);\n\t\t}\n\t}\n\n\t_getRawIndentString() {\n\t\tthis._ensureindentStr();\n\t\treturn this.indentStr;\n\t}\n\n\tgetIndentString() {\n\t\tthis._ensureindentStr();\n\t\treturn this.indentStr === null ? '\\t' : this.indentStr;\n\t}\n\n\tindent(indentStr, options) {\n\t\tconst pattern = /^[^\\r\\n]/gm;\n\n\t\tif (isObject(indentStr)) {\n\t\t\toptions = indentStr;\n\t\t\tindentStr = undefined;\n\t\t}\n\n\t\tif (indentStr === undefined) {\n\t\t\tthis._ensureindentStr();\n\t\t\tindentStr = this.indentStr || '\\t';\n\t\t}\n\n\t\tif (indentStr === '') return this; // noop\n\n\t\toptions = options || {};\n\n\t\t// Process exclusion ranges\n\t\tconst isExcluded = {};\n\n\t\tif (options.exclude) {\n\t\t\tconst exclusions =\n\t\t\t\ttypeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;\n\t\t\texclusions.forEach((exclusion) => {\n\t\t\t\tfor (let i = exclusion[0]; i < exclusion[1]; i += 1) {\n\t\t\t\t\tisExcluded[i] = true;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\tlet shouldIndentNextCharacter = options.indentStart !== false;\n\t\tconst replacer = (match) => {\n\t\t\tif (shouldIndentNextCharacter) return `${indentStr}${match}`;\n\t\t\tshouldIndentNextCharacter = true;\n\t\t\treturn match;\n\t\t};\n\n\t\tthis.intro = this.intro.replace(pattern, replacer);\n\n\t\tlet charIndex = 0;\n\t\tlet chunk = this.firstChunk;\n\n\t\twhile (chunk) {\n\t\t\tconst end = chunk.end;\n\n\t\t\tif (chunk.edited) {\n\t\t\t\tif (!isExcluded[charIndex]) {\n\t\t\t\t\tchunk.content = chunk.content.replace(pattern, replacer);\n\n\t\t\t\t\tif (chunk.content.length) {\n\t\t\t\t\t\tshouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\\n';\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcharIndex = chunk.start;\n\n\t\t\t\twhile (charIndex < end) {\n\t\t\t\t\tif (!isExcluded[charIndex]) {\n\t\t\t\t\t\tconst char = this.original[charIndex];\n\n\t\t\t\t\t\tif (char === '\\n') {\n\t\t\t\t\t\t\tshouldIndentNextCharacter = true;\n\t\t\t\t\t\t} else if (char !== '\\r' && shouldIndentNextCharacter) {\n\t\t\t\t\t\t\tshouldIndentNextCharacter = false;\n\n\t\t\t\t\t\t\tif (charIndex === chunk.start) {\n\t\t\t\t\t\t\t\tchunk.prependRight(indentStr);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis._splitChunk(chunk, charIndex);\n\t\t\t\t\t\t\t\tchunk = chunk.next;\n\t\t\t\t\t\t\t\tchunk.prependRight(indentStr);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tcharIndex += 1;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tcharIndex = chunk.end;\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\tthis.outro = this.outro.replace(pattern, replacer);\n\n\t\treturn this;\n\t}\n\n\tinsert() {\n\t\tthrow new Error(\n\t\t\t'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',\n\t\t);\n\t}\n\n\tinsertLeft(index, content) {\n\t\tif (!warned.insertLeft) {\n\t\t\tconsole.warn(\n\t\t\t\t'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',\n\t\t\t);\n\t\t\twarned.insertLeft = true;\n\t\t}\n\n\t\treturn this.appendLeft(index, content);\n\t}\n\n\tinsertRight(index, content) {\n\t\tif (!warned.insertRight) {\n\t\t\tconsole.warn(\n\t\t\t\t'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',\n\t\t\t);\n\t\t\twarned.insertRight = true;\n\t\t}\n\n\t\treturn this.prependRight(index, content);\n\t}\n\n\tmove(start, end, index) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\t\tindex = index + this.offset;\n\n\t\tif (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');\n\n\t\tif (DEBUG) this.stats.time('move');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\t\tthis._split(index);\n\n\t\tconst first = this.byStart[start];\n\t\tconst last = this.byEnd[end];\n\n\t\tconst oldLeft = first.previous;\n\t\tconst oldRight = last.next;\n\n\t\tconst newRight = this.byStart[index];\n\t\tif (!newRight && last === this.lastChunk) return this;\n\t\tconst newLeft = newRight ? newRight.previous : this.lastChunk;\n\n\t\tif (oldLeft) oldLeft.next = oldRight;\n\t\tif (oldRight) oldRight.previous = oldLeft;\n\n\t\tif (newLeft) newLeft.next = first;\n\t\tif (newRight) newRight.previous = last;\n\n\t\tif (!first.previous) this.firstChunk = last.next;\n\t\tif (!last.next) {\n\t\t\tthis.lastChunk = first.previous;\n\t\t\tthis.lastChunk.next = null;\n\t\t}\n\n\t\tfirst.previous = newLeft;\n\t\tlast.next = newRight || null;\n\n\t\tif (!newLeft) this.firstChunk = first;\n\t\tif (!newRight) this.lastChunk = last;\n\n\t\tif (DEBUG) this.stats.timeEnd('move');\n\t\treturn this;\n\t}\n\n\toverwrite(start, end, content, options) {\n\t\toptions = options || {};\n\t\treturn this.update(start, end, content, { ...options, overwrite: !options.contentOnly });\n\t}\n\n\tupdate(start, end, content, options) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('replacement content must be a string');\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tif (end > this.original.length) throw new Error('end is out of bounds');\n\t\tif (start === end)\n\t\t\tthrow new Error(\n\t\t\t\t'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',\n\t\t\t);\n\n\t\tif (DEBUG) this.stats.time('overwrite');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\n\t\tif (options === true) {\n\t\t\tif (!warned.storeName) {\n\t\t\t\tconsole.warn(\n\t\t\t\t\t'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',\n\t\t\t\t);\n\t\t\t\twarned.storeName = true;\n\t\t\t}\n\n\t\t\toptions = { storeName: true };\n\t\t}\n\t\tconst storeName = options !== undefined ? options.storeName : false;\n\t\tconst overwrite = options !== undefined ? options.overwrite : false;\n\n\t\tif (storeName) {\n\t\t\tconst original = this.original.slice(start, end);\n\t\t\tObject.defineProperty(this.storedNames, original, {\n\t\t\t\twritable: true,\n\t\t\t\tvalue: true,\n\t\t\t\tenumerable: true,\n\t\t\t});\n\t\t}\n\n\t\tconst first = this.byStart[start];\n\t\tconst last = this.byEnd[end];\n\n\t\tif (first) {\n\t\t\tlet chunk = first;\n\t\t\twhile (chunk !== last) {\n\t\t\t\tif (chunk.next !== this.byStart[chunk.end]) {\n\t\t\t\t\tthrow new Error('Cannot overwrite across a split point');\n\t\t\t\t}\n\t\t\t\tchunk = chunk.next;\n\t\t\t\tchunk.edit('', false);\n\t\t\t}\n\n\t\t\tfirst.edit(content, storeName, !overwrite);\n\t\t} else {\n\t\t\t// must be inserting at the end\n\t\t\tconst newChunk = new Chunk(start, end, '').edit(content, storeName);\n\n\t\t\t// TODO last chunk in the array may not be the last chunk, if it's moved...\n\t\t\tlast.next = newChunk;\n\t\t\tnewChunk.previous = last;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('overwrite');\n\t\treturn this;\n\t}\n\n\tprepend(content) {\n\t\tif (typeof content !== 'string') throw new TypeError('outro content must be a string');\n\n\t\tthis.intro = content + this.intro;\n\t\treturn this;\n\t}\n\n\tprependLeft(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('insertRight');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byEnd[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.prependLeft(content);\n\t\t} else {\n\t\t\tthis.intro = content + this.intro;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('insertRight');\n\t\treturn this;\n\t}\n\n\tprependRight(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('insertRight');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byStart[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.prependRight(content);\n\t\t} else {\n\t\t\tthis.outro = content + this.outro;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('insertRight');\n\t\treturn this;\n\t}\n\n\tremove(start, end) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tif (start === end) return this;\n\n\t\tif (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');\n\t\tif (start > end) throw new Error('end must be greater than start');\n\n\t\tif (DEBUG) this.stats.time('remove');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\n\t\tlet chunk = this.byStart[start];\n\n\t\twhile (chunk) {\n\t\t\tchunk.intro = '';\n\t\t\tchunk.outro = '';\n\t\t\tchunk.edit('');\n\n\t\t\tchunk = end > chunk.end ? this.byStart[chunk.end] : null;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('remove');\n\t\treturn this;\n\t}\n\n\treset(start, end) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tif (start === end) return this;\n\n\t\tif (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');\n\t\tif (start > end) throw new Error('end must be greater than start');\n\n\t\tif (DEBUG) this.stats.time('reset');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\n\t\tlet chunk = this.byStart[start];\n\n\t\twhile (chunk) {\n\t\t\tchunk.reset();\n\n\t\t\tchunk = end > chunk.end ? this.byStart[chunk.end] : null;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('reset');\n\t\treturn this;\n\t}\n\n\tlastChar() {\n\t\tif (this.outro.length) return this.outro[this.outro.length - 1];\n\t\tlet chunk = this.lastChunk;\n\t\tdo {\n\t\t\tif (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];\n\t\t\tif (chunk.content.length) return chunk.content[chunk.content.length - 1];\n\t\t\tif (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];\n\t\t} while ((chunk = chunk.previous));\n\t\tif (this.intro.length) return this.intro[this.intro.length - 1];\n\t\treturn '';\n\t}\n\n\tlastLine() {\n\t\tlet lineIndex = this.outro.lastIndexOf(n);\n\t\tif (lineIndex !== -1) return this.outro.substr(lineIndex + 1);\n\t\tlet lineStr = this.outro;\n\t\tlet chunk = this.lastChunk;\n\t\tdo {\n\t\t\tif (chunk.outro.length > 0) {\n\t\t\t\tlineIndex = chunk.outro.lastIndexOf(n);\n\t\t\t\tif (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;\n\t\t\t\tlineStr = chunk.outro + lineStr;\n\t\t\t}\n\n\t\t\tif (chunk.content.length > 0) {\n\t\t\t\tlineIndex = chunk.content.lastIndexOf(n);\n\t\t\t\tif (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;\n\t\t\t\tlineStr = chunk.content + lineStr;\n\t\t\t}\n\n\t\t\tif (chunk.intro.length > 0) {\n\t\t\t\tlineIndex = chunk.intro.lastIndexOf(n);\n\t\t\t\tif (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;\n\t\t\t\tlineStr = chunk.intro + lineStr;\n\t\t\t}\n\t\t} while ((chunk = chunk.previous));\n\t\tlineIndex = this.intro.lastIndexOf(n);\n\t\tif (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;\n\t\treturn this.intro + lineStr;\n\t}\n\n\tslice(start = 0, end = this.original.length - this.offset) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tlet result = '';\n\n\t\t// find start chunk\n\t\tlet chunk = this.firstChunk;\n\t\twhile (chunk && (chunk.start > start || chunk.end <= start)) {\n\t\t\t// found end chunk before start\n\t\t\tif (chunk.start < end && chunk.end >= end) {\n\t\t\t\treturn result;\n\t\t\t}\n\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\tif (chunk && chunk.edited && chunk.start !== start)\n\t\t\tthrow new Error(`Cannot use replaced character ${start} as slice start anchor.`);\n\n\t\tconst startChunk = chunk;\n\t\twhile (chunk) {\n\t\t\tif (chunk.intro && (startChunk !== chunk || chunk.start === start)) {\n\t\t\t\tresult += chunk.intro;\n\t\t\t}\n\n\t\t\tconst containsEnd = chunk.start < end && chunk.end >= end;\n\t\t\tif (containsEnd && chunk.edited && chunk.end !== end)\n\t\t\t\tthrow new Error(`Cannot use replaced character ${end} as slice end anchor.`);\n\n\t\t\tconst sliceStart = startChunk === chunk ? start - chunk.start : 0;\n\t\t\tconst sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;\n\n\t\t\tresult += chunk.content.slice(sliceStart, sliceEnd);\n\n\t\t\tif (chunk.outro && (!containsEnd || chunk.end === end)) {\n\t\t\t\tresult += chunk.outro;\n\t\t\t}\n\n\t\t\tif (containsEnd) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t// TODO deprecate this? not really very useful\n\tsnip(start, end) {\n\t\tconst clone = this.clone();\n\t\tclone.remove(0, start);\n\t\tclone.remove(end, clone.original.length);\n\n\t\treturn clone;\n\t}\n\n\t_split(index) {\n\t\tif (this.byStart[index] || this.byEnd[index]) return;\n\n\t\tif (DEBUG) this.stats.time('_split');\n\n\t\tlet chunk = this.lastSearchedChunk;\n\t\tlet previousChunk = chunk;\n\t\tconst searchForward = index > chunk.end;\n\n\t\twhile (chunk) {\n\t\t\tif (chunk.contains(index)) return this._splitChunk(chunk, index);\n\n\t\t\tchunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];\n\n\t\t\t// Prevent infinite loop (e.g. via empty chunks, where start === end)\n\t\t\tif (chunk === previousChunk) return;\n\n\t\t\tpreviousChunk = chunk;\n\t\t}\n\t}\n\n\t_splitChunk(chunk, index) {\n\t\tif (chunk.edited && chunk.content.length) {\n\t\t\t// zero-length edited chunks are a special case (overlapping replacements)\n\t\t\tconst loc = getLocator(this.original)(index);\n\t\t\tthrow new Error(\n\t\t\t\t`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – \"${chunk.original}\")`,\n\t\t\t);\n\t\t}\n\n\t\tconst newChunk = chunk.split(index);\n\n\t\tthis.byEnd[index] = chunk;\n\t\tthis.byStart[index] = newChunk;\n\t\tthis.byEnd[newChunk.end] = newChunk;\n\n\t\tif (chunk === this.lastChunk) this.lastChunk = newChunk;\n\n\t\tthis.lastSearchedChunk = chunk;\n\t\tif (DEBUG) this.stats.timeEnd('_split');\n\t\treturn true;\n\t}\n\n\ttoString() {\n\t\tlet str = this.intro;\n\n\t\tlet chunk = this.firstChunk;\n\t\twhile (chunk) {\n\t\t\tstr += chunk.toString();\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\treturn str + this.outro;\n\t}\n\n\tisEmpty() {\n\t\tlet chunk = this.firstChunk;\n\t\tdo {\n\t\t\tif (\n\t\t\t\t(chunk.intro.length && chunk.intro.trim()) ||\n\t\t\t\t(chunk.content.length && chunk.content.trim()) ||\n\t\t\t\t(chunk.outro.length && chunk.outro.trim())\n\t\t\t)\n\t\t\t\treturn false;\n\t\t} while ((chunk = chunk.next));\n\t\treturn true;\n\t}\n\n\tlength() {\n\t\tlet chunk = this.firstChunk;\n\t\tlet length = 0;\n\t\tdo {\n\t\t\tlength += chunk.intro.length + chunk.content.length + chunk.outro.length;\n\t\t} while ((chunk = chunk.next));\n\t\treturn length;\n\t}\n\n\ttrimLines() {\n\t\treturn this.trim('[\\\\r\\\\n]');\n\t}\n\n\ttrim(charType) {\n\t\treturn this.trimStart(charType).trimEnd(charType);\n\t}\n\n\ttrimEndAborted(charType) {\n\t\tconst rx = new RegExp((charType || '\\\\s') + '+$');\n\n\t\tthis.outro = this.outro.replace(rx, '');\n\t\tif (this.outro.length) return true;\n\n\t\tlet chunk = this.lastChunk;\n\n\t\tdo {\n\t\t\tconst end = chunk.end;\n\t\t\tconst aborted = chunk.trimEnd(rx);\n\n\t\t\t// if chunk was trimmed, we have a new lastChunk\n\t\t\tif (chunk.end !== end) {\n\t\t\t\tif (this.lastChunk === chunk) {\n\t\t\t\t\tthis.lastChunk = chunk.next;\n\t\t\t\t}\n\n\t\t\t\tthis.byEnd[chunk.end] = chunk;\n\t\t\t\tthis.byStart[chunk.next.start] = chunk.next;\n\t\t\t\tthis.byEnd[chunk.next.end] = chunk.next;\n\t\t\t}\n\n\t\t\tif (aborted) return true;\n\t\t\tchunk = chunk.previous;\n\t\t} while (chunk);\n\n\t\treturn false;\n\t}\n\n\ttrimEnd(charType) {\n\t\tthis.trimEndAborted(charType);\n\t\treturn this;\n\t}\n\ttrimStartAborted(charType) {\n\t\tconst rx = new RegExp('^' + (charType || '\\\\s') + '+');\n\n\t\tthis.intro = this.intro.replace(rx, '');\n\t\tif (this.intro.length) return true;\n\n\t\tlet chunk = this.firstChunk;\n\n\t\tdo {\n\t\t\tconst end = chunk.end;\n\t\t\tconst aborted = chunk.trimStart(rx);\n\n\t\t\tif (chunk.end !== end) {\n\t\t\t\t// special case...\n\t\t\t\tif (chunk === this.lastChunk) this.lastChunk = chunk.next;\n\n\t\t\t\tthis.byEnd[chunk.end] = chunk;\n\t\t\t\tthis.byStart[chunk.next.start] = chunk.next;\n\t\t\t\tthis.byEnd[chunk.next.end] = chunk.next;\n\t\t\t}\n\n\t\t\tif (aborted) return true;\n\t\t\tchunk = chunk.next;\n\t\t} while (chunk);\n\n\t\treturn false;\n\t}\n\n\ttrimStart(charType) {\n\t\tthis.trimStartAborted(charType);\n\t\treturn this;\n\t}\n\n\thasChanged() {\n\t\treturn this.original !== this.toString();\n\t}\n\n\t_replaceRegexp(searchValue, replacement) {\n\t\tfunction getReplacement(match, str) {\n\t\t\tif (typeof replacement === 'string') {\n\t\t\t\treturn replacement.replace(/\\$(\\$|&|\\d+)/g, (_, i) => {\n\t\t\t\t\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter\n\t\t\t\t\tif (i === '$') return '$';\n\t\t\t\t\tif (i === '&') return match[0];\n\t\t\t\t\tconst num = +i;\n\t\t\t\t\tif (num < match.length) return match[+i];\n\t\t\t\t\treturn `$${i}`;\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\treturn replacement(...match, match.index, str, match.groups);\n\t\t\t}\n\t\t}\n\t\tfunction matchAll(re, str) {\n\t\t\tlet match;\n\t\t\tconst matches = [];\n\t\t\twhile ((match = re.exec(str))) {\n\t\t\t\tmatches.push(match);\n\t\t\t}\n\t\t\treturn matches;\n\t\t}\n\t\tif (searchValue.global) {\n\t\t\tconst matches = matchAll(searchValue, this.original);\n\t\t\tmatches.forEach((match) => {\n\t\t\t\tif (match.index != null) {\n\t\t\t\t\tconst replacement = getReplacement(match, this.original);\n\t\t\t\t\tif (replacement !== match[0]) {\n\t\t\t\t\t\tthis.overwrite(match.index, match.index + match[0].length, replacement);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t} else {\n\t\t\tconst match = this.original.match(searchValue);\n\t\t\tif (match && match.index != null) {\n\t\t\t\tconst replacement = getReplacement(match, this.original);\n\t\t\t\tif (replacement !== match[0]) {\n\t\t\t\t\tthis.overwrite(match.index, match.index + match[0].length, replacement);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t_replaceString(string, replacement) {\n\t\tconst { original } = this;\n\t\tconst index = original.indexOf(string);\n\n\t\tif (index !== -1) {\n\t\t\tif (typeof replacement === 'function') {\n\t\t\t\treplacement = replacement(string, index, original);\n\t\t\t}\n\t\t\tif (string !== replacement) {\n\t\t\t\tthis.overwrite(index, index + string.length, replacement);\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t}\n\n\treplace(searchValue, replacement) {\n\t\tif (typeof searchValue === 'string') {\n\t\t\treturn this._replaceString(searchValue, replacement);\n\t\t}\n\n\t\treturn this._replaceRegexp(searchValue, replacement);\n\t}\n\n\t_replaceAllString(string, replacement) {\n\t\tconst { original } = this;\n\t\tconst stringLength = string.length;\n\t\tfor (\n\t\t\tlet index = original.indexOf(string);\n\t\t\tindex !== -1;\n\t\t\tindex = original.indexOf(string, index + stringLength)\n\t\t) {\n\t\t\tconst previous = original.slice(index, index + stringLength);\n\t\t\tlet _replacement = replacement;\n\t\t\tif (typeof replacement === 'function') {\n\t\t\t\t_replacement = replacement(previous, index, original);\n\t\t\t}\n\t\t\tif (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);\n\t\t}\n\n\t\treturn this;\n\t}\n\n\treplaceAll(searchValue, replacement) {\n\t\tif (typeof searchValue === 'string') {\n\t\t\treturn this._replaceAllString(searchValue, replacement);\n\t\t}\n\n\t\tif (!searchValue.global) {\n\t\t\tthrow new TypeError(\n\t\t\t\t'MagicString.prototype.replaceAll called with a non-global RegExp argument',\n\t\t\t);\n\t\t}\n\n\t\treturn this._replaceRegexp(searchValue, replacement);\n\t}\n}\n","import MagicString from './MagicString.js';\nimport SourceMap from './SourceMap.js';\nimport getRelativePath from './utils/getRelativePath.js';\nimport isObject from './utils/isObject.js';\nimport getLocator from './utils/getLocator.js';\nimport Mappings from './utils/Mappings.js';\n\nconst hasOwnProp = Object.prototype.hasOwnProperty;\n\nexport default class Bundle {\n\tconstructor(options = {}) {\n\t\tthis.intro = options.intro || '';\n\t\tthis.separator = options.separator !== undefined ? options.separator : '\\n';\n\t\tthis.sources = [];\n\t\tthis.uniqueSources = [];\n\t\tthis.uniqueSourceIndexByFilename = {};\n\t}\n\n\taddSource(source) {\n\t\tif (source instanceof MagicString) {\n\t\t\treturn this.addSource({\n\t\t\t\tcontent: source,\n\t\t\t\tfilename: source.filename,\n\t\t\t\tseparator: this.separator,\n\t\t\t});\n\t\t}\n\n\t\tif (!isObject(source) || !source.content) {\n\t\t\tthrow new Error(\n\t\t\t\t'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`',\n\t\t\t);\n\t\t}\n\n\t\t['filename', 'ignoreList', 'indentExclusionRanges', 'separator'].forEach((option) => {\n\t\t\tif (!hasOwnProp.call(source, option)) source[option] = source.content[option];\n\t\t});\n\n\t\tif (source.separator === undefined) {\n\t\t\t// TODO there's a bunch of this sort of thing, needs cleaning up\n\t\t\tsource.separator = this.separator;\n\t\t}\n\n\t\tif (source.filename) {\n\t\t\tif (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {\n\t\t\t\tthis.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;\n\t\t\t\tthis.uniqueSources.push({ filename: source.filename, content: source.content.original });\n\t\t\t} else {\n\t\t\t\tconst uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];\n\t\t\t\tif (source.content.original !== uniqueSource.content) {\n\t\t\t\t\tthrow new Error(`Illegal source: same filename (${source.filename}), different contents`);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tthis.sources.push(source);\n\t\treturn this;\n\t}\n\n\tappend(str, options) {\n\t\tthis.addSource({\n\t\t\tcontent: new MagicString(str),\n\t\t\tseparator: (options && options.separator) || '',\n\t\t});\n\n\t\treturn this;\n\t}\n\n\tclone() {\n\t\tconst bundle = new Bundle({\n\t\t\tintro: this.intro,\n\t\t\tseparator: this.separator,\n\t\t});\n\n\t\tthis.sources.forEach((source) => {\n\t\t\tbundle.addSource({\n\t\t\t\tfilename: source.filename,\n\t\t\t\tcontent: source.content.clone(),\n\t\t\t\tseparator: source.separator,\n\t\t\t});\n\t\t});\n\n\t\treturn bundle;\n\t}\n\n\tgenerateDecodedMap(options = {}) {\n\t\tconst names = [];\n\t\tlet x_google_ignoreList = undefined;\n\t\tthis.sources.forEach((source) => {\n\t\t\tObject.keys(source.content.storedNames).forEach((name) => {\n\t\t\t\tif (!~names.indexOf(name)) names.push(name);\n\t\t\t});\n\t\t});\n\n\t\tconst mappings = new Mappings(options.hires);\n\n\t\tif (this.intro) {\n\t\t\tmappings.advance(this.intro);\n\t\t}\n\n\t\tthis.sources.forEach((source, i) => {\n\t\t\tif (i > 0) {\n\t\t\t\tmappings.advance(this.separator);\n\t\t\t}\n\n\t\t\tconst sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1;\n\t\t\tconst magicString = source.content;\n\t\t\tconst locate = getLocator(magicString.original);\n\n\t\t\tif (magicString.intro) {\n\t\t\t\tmappings.advance(magicString.intro);\n\t\t\t}\n\n\t\t\tmagicString.firstChunk.eachNext((chunk) => {\n\t\t\t\tconst loc = locate(chunk.start);\n\n\t\t\t\tif (chunk.intro.length) mappings.advance(chunk.intro);\n\n\t\t\t\tif (source.filename) {\n\t\t\t\t\tif (chunk.edited) {\n\t\t\t\t\t\tmappings.addEdit(\n\t\t\t\t\t\t\tsourceIndex,\n\t\t\t\t\t\t\tchunk.content,\n\t\t\t\t\t\t\tloc,\n\t\t\t\t\t\t\tchunk.storeName ? names.indexOf(chunk.original) : -1,\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tmappings.addUneditedChunk(\n\t\t\t\t\t\t\tsourceIndex,\n\t\t\t\t\t\t\tchunk,\n\t\t\t\t\t\t\tmagicString.original,\n\t\t\t\t\t\t\tloc,\n\t\t\t\t\t\t\tmagicString.sourcemapLocations,\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tmappings.advance(chunk.content);\n\t\t\t\t}\n\n\t\t\t\tif (chunk.outro.length) mappings.advance(chunk.outro);\n\t\t\t});\n\n\t\t\tif (magicString.outro) {\n\t\t\t\tmappings.advance(magicString.outro);\n\t\t\t}\n\n\t\t\tif (source.ignoreList && sourceIndex !== -1) {\n\t\t\t\tif (x_google_ignoreList === undefined) {\n\t\t\t\t\tx_google_ignoreList = [];\n\t\t\t\t}\n\t\t\t\tx_google_ignoreList.push(sourceIndex);\n\t\t\t}\n\t\t});\n\n\t\treturn {\n\t\t\tfile: options.file ? options.file.split(/[/\\\\]/).pop() : undefined,\n\t\t\tsources: this.uniqueSources.map((source) => {\n\t\t\t\treturn options.file ? getRelativePath(options.file, source.filename) : source.filename;\n\t\t\t}),\n\t\t\tsourcesContent: this.uniqueSources.map((source) => {\n\t\t\t\treturn options.includeContent ? source.content : null;\n\t\t\t}),\n\t\t\tnames,\n\t\t\tmappings: mappings.raw,\n\t\t\tx_google_ignoreList,\n\t\t};\n\t}\n\n\tgenerateMap(options) {\n\t\treturn new SourceMap(this.generateDecodedMap(options));\n\t}\n\n\tgetIndentString() {\n\t\tconst indentStringCounts = {};\n\n\t\tthis.sources.forEach((source) => {\n\t\t\tconst indentStr = source.content._getRawIndentString();\n\n\t\t\tif (indentStr === null) return;\n\n\t\t\tif (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0;\n\t\t\tindentStringCounts[indentStr] += 1;\n\t\t});\n\n\t\treturn (\n\t\t\tObject.keys(indentStringCounts).sort((a, b) => {\n\t\t\t\treturn indentStringCounts[a] - indentStringCounts[b];\n\t\t\t})[0] || '\\t'\n\t\t);\n\t}\n\n\tindent(indentStr) {\n\t\tif (!arguments.length) {\n\t\t\tindentStr = this.getIndentString();\n\t\t}\n\n\t\tif (indentStr === '') return this; // noop\n\n\t\tlet trailingNewline = !this.intro || this.intro.slice(-1) === '\\n';\n\n\t\tthis.sources.forEach((source, i) => {\n\t\t\tconst separator = source.separator !== undefined ? source.separator : this.separator;\n\t\t\tconst indentStart = trailingNewline || (i > 0 && /\\r?\\n$/.test(separator));\n\n\t\t\tsource.content.indent(indentStr, {\n\t\t\t\texclude: source.indentExclusionRanges,\n\t\t\t\tindentStart, //: trailingNewline || /\\r?\\n$/.test( separator ) //true///\\r?\\n/.test( separator )\n\t\t\t});\n\n\t\t\ttrailingNewline = source.content.lastChar() === '\\n';\n\t\t});\n\n\t\tif (this.intro) {\n\t\t\tthis.intro =\n\t\t\t\tindentStr +\n\t\t\t\tthis.intro.replace(/^[^\\n]/gm, (match, index) => {\n\t\t\t\t\treturn index > 0 ? indentStr + match : match;\n\t\t\t\t});\n\t\t}\n\n\t\treturn this;\n\t}\n\n\tprepend(str) {\n\t\tthis.intro = str + this.intro;\n\t\treturn this;\n\t}\n\n\ttoString() {\n\t\tconst body = this.sources\n\t\t\t.map((source, i) => {\n\t\t\t\tconst separator = source.separator !== undefined ? source.separator : this.separator;\n\t\t\t\tconst str = (i > 0 ? separator : '') + source.content.toString();\n\n\t\t\t\treturn str;\n\t\t\t})\n\t\t\t.join('');\n\n\t\treturn this.intro + body;\n\t}\n\n\tisEmpty() {\n\t\tif (this.intro.length && this.intro.trim()) return false;\n\t\tif (this.sources.some((source) => !source.content.isEmpty())) return false;\n\t\treturn true;\n\t}\n\n\tlength() {\n\t\treturn this.sources.reduce(\n\t\t\t(length, source) => length + source.content.length(),\n\t\t\tthis.intro.length,\n\t\t);\n\t}\n\n\ttrimLines() {\n\t\treturn this.trim('[\\\\r\\\\n]');\n\t}\n\n\ttrim(charType) {\n\t\treturn this.trimStart(charType).trimEnd(charType);\n\t}\n\n\ttrimStart(charType) {\n\t\tconst rx = new RegExp('^' + (charType || '\\\\s') + '+');\n\t\tthis.intro = this.intro.replace(rx, '');\n\n\t\tif (!this.intro) {\n\t\t\tlet source;\n\t\t\tlet i = 0;\n\n\t\t\tdo {\n\t\t\t\tsource = this.sources[i++];\n\t\t\t\tif (!source) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t} while (!source.content.trimStartAborted(charType));\n\t\t}\n\n\t\treturn this;\n\t}\n\n\ttrimEnd(charType) {\n\t\tconst rx = new RegExp((charType || '\\\\s') + '+$');\n\n\t\tlet source;\n\t\tlet i = this.sources.length - 1;\n\n\t\tdo {\n\t\t\tsource = this.sources[i--];\n\t\t\tif (!source) {\n\t\t\t\tthis.intro = this.intro.replace(rx, '');\n\t\t\t\tbreak;\n\t\t\t}\n\t\t} while (!source.content.trimEndAborted(charType));\n\n\t\treturn this;\n\t}\n}\n","import MagicString from './MagicString.js';\nimport Bundle from './Bundle.js';\nimport SourceMap from './SourceMap.js';\n\nMagicString.Bundle = Bundle;\nMagicString.SourceMap = SourceMap;\nMagicString.default = MagicString; // work around TypeScript bug https://github.com/Rich-Harris/magic-string/pull/121\n\nexport default MagicString;\n"],"names":["encode"],"mappings":"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"} \ No newline at end of file diff --git a/frontend/node_modules/magic-string/dist/magic-string.es.d.mts b/frontend/node_modules/magic-string/dist/magic-string.es.d.mts new file mode 100644 index 0000000..76cc537 --- /dev/null +++ b/frontend/node_modules/magic-string/dist/magic-string.es.d.mts @@ -0,0 +1,289 @@ +export interface BundleOptions { + intro?: string; + separator?: string; +} + +export interface SourceMapOptions { + /** + * Whether the mapping should be high-resolution. + * Hi-res mappings map every single character, meaning (for example) your devtools will always + * be able to pinpoint the exact location of function calls and so on. + * With lo-res mappings, devtools may only be able to identify the correct + * line - but they're quicker to generate and less bulky. + * You can also set `"boundary"` to generate a semi-hi-res mappings segmented per word boundary + * instead of per character, suitable for string semantics that are separated by words. + * If sourcemap locations have been specified with s.addSourceMapLocation(), they will be used here. + */ + hires?: boolean | 'boundary'; + /** + * The filename where you plan to write the sourcemap. + */ + file?: string; + /** + * The filename of the file containing the original source. + */ + source?: string; + /** + * Whether to include the original content in the map's sourcesContent array. + */ + includeContent?: boolean; +} + +export type SourceMapSegment = + | [number] + | [number, number, number, number] + | [number, number, number, number, number]; + +export interface DecodedSourceMap { + file: string; + sources: string[]; + sourcesContent?: string[]; + names: string[]; + mappings: SourceMapSegment[][]; + x_google_ignoreList?: number[]; +} + +export class SourceMap { + constructor(properties: DecodedSourceMap); + + version: number; + file: string; + sources: string[]; + sourcesContent?: string[]; + names: string[]; + mappings: string; + x_google_ignoreList?: number[]; + debugId?: string; + + /** + * Returns the equivalent of `JSON.stringify(map)` + */ + toString(): string; + /** + * Returns a DataURI containing the sourcemap. Useful for doing this sort of thing: + * `generateMap(options?: SourceMapOptions): SourceMap;` + */ + toUrl(): string; +} + +export class Bundle { + constructor(options?: BundleOptions); + /** + * Adds the specified source to the bundle, which can either be a `MagicString` object directly, + * or an options object that holds a magic string `content` property and optionally provides + * a `filename` for the source within the bundle, as well as an optional `ignoreList` hint + * (which defaults to `false`). The `filename` is used when constructing the source map for the + * bundle, to identify this `source` in the source map's `sources` field. The `ignoreList` hint + * is used to populate the `x_google_ignoreList` extension field in the source map, which is a + * mechanism for tools to signal to debuggers that certain sources should be ignored by default + * (depending on user preferences). + */ + addSource( + source: MagicString | { filename?: string; content: MagicString; ignoreList?: boolean }, + ): this; + append(str: string, options?: BundleOptions): this; + clone(): this; + generateMap( + options?: SourceMapOptions, + ): Omit & { sourcesContent: Array }; + generateDecodedMap( + options?: SourceMapOptions, + ): Omit & { sourcesContent: Array }; + getIndentString(): string; + indent(indentStr?: string): this; + indentExclusionRanges: ExclusionRange | Array; + prepend(str: string): this; + toString(): string; + trimLines(): this; + trim(charType?: string): this; + trimStart(charType?: string): this; + trimEnd(charType?: string): this; + isEmpty(): boolean; + length(): number; +} + +export type ExclusionRange = [number, number]; + +export interface MagicStringOptions { + filename?: string; + indentExclusionRanges?: ExclusionRange | Array; + offset?: number; +} + +export interface IndentOptions { + exclude?: ExclusionRange | Array; + indentStart?: boolean; +} + +export interface OverwriteOptions { + storeName?: boolean; + contentOnly?: boolean; +} + +export interface UpdateOptions { + storeName?: boolean; + overwrite?: boolean; +} + +export default class MagicString { + constructor(str: string, options?: MagicStringOptions); + /** + * Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is false. + */ + addSourcemapLocation(char: number): void; + /** + * Appends the specified content to the end of the string. + */ + append(content: string): this; + /** + * Appends the specified content at the index in the original string. + * If a range *ending* with index is subsequently moved, the insert will be moved with it. + * See also `s.prependLeft(...)`. + */ + appendLeft(index: number, content: string): this; + /** + * Appends the specified content at the index in the original string. + * If a range *starting* with index is subsequently moved, the insert will be moved with it. + * See also `s.prependRight(...)`. + */ + appendRight(index: number, content: string): this; + /** + * Does what you'd expect. + */ + clone(): this; + /** + * Generates a version 3 sourcemap. + */ + generateMap(options?: SourceMapOptions): SourceMap; + /** + * Generates a sourcemap object with raw mappings in array form, rather than encoded as a string. + * Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead. + */ + generateDecodedMap(options?: SourceMapOptions): DecodedSourceMap; + getIndentString(): string; + + /** + * Prefixes each line of the string with prefix. + * If prefix is not supplied, the indentation will be guessed from the original content, falling back to a single tab character. + */ + indent(options?: IndentOptions): this; + /** + * Prefixes each line of the string with prefix. + * If prefix is not supplied, the indentation will be guessed from the original content, falling back to a single tab character. + * + * The options argument can have an exclude property, which is an array of [start, end] character ranges. + * These ranges will be excluded from the indentation - useful for (e.g.) multiline strings. + */ + indent(indentStr?: string, options?: IndentOptions): this; + indentExclusionRanges: ExclusionRange | Array; + + /** + * Moves the characters from `start` and `end` to `index`. + */ + move(start: number, end: number, index: number): this; + /** + * Replaces the characters from `start` to `end` with `content`, along with the appended/prepended content in + * that range. The same restrictions as `s.remove()` apply. + * + * The fourth argument is optional. It can have a storeName property — if true, the original name will be stored + * for later inclusion in a sourcemap's names array — and a contentOnly property which determines whether only + * the content is overwritten, or anything that was appended/prepended to the range as well. + * + * It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content. + */ + overwrite( + start: number, + end: number, + content: string, + options?: boolean | OverwriteOptions, + ): this; + /** + * Replaces the characters from `start` to `end` with `content`. The same restrictions as `s.remove()` apply. + * + * The fourth argument is optional. It can have a storeName property — if true, the original name will be stored + * for later inclusion in a sourcemap's names array — and an overwrite property which determines whether only + * the content is overwritten, or anything that was appended/prepended to the range as well. + */ + update(start: number, end: number, content: string, options?: boolean | UpdateOptions): this; + /** + * Prepends the string with the specified content. + */ + prepend(content: string): this; + /** + * Same as `s.appendLeft(...)`, except that the inserted content will go *before* any previous appends or prepends at index + */ + prependLeft(index: number, content: string): this; + /** + * Same as `s.appendRight(...)`, except that the inserted content will go *before* any previous appends or prepends at `index` + */ + prependRight(index: number, content: string): this; + /** + * Removes the characters from `start` to `end` (of the original string, **not** the generated string). + * Removing the same content twice, or making removals that partially overlap, will cause an error. + */ + remove(start: number, end: number): this; + /** + * Reset the modified characters from `start` to `end` (of the original string, **not** the generated string). + */ + reset(start: number, end: number): this; + /** + * Returns the content of the generated string that corresponds to the slice between `start` and `end` of the original string. + * Throws error if the indices are for characters that were already removed. + */ + slice(start: number, end: number): string; + /** + * Returns a clone of `s`, with all content before the `start` and `end` characters of the original string removed. + */ + snip(start: number, end: number): this; + /** + * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start and end. + */ + trim(charType?: string): this; + /** + * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start. + */ + trimStart(charType?: string): this; + /** + * Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end. + */ + trimEnd(charType?: string): this; + /** + * Removes empty lines from the start and end. + */ + trimLines(): this; + /** + * String replacement with RegExp or string. + */ + replace( + regex: RegExp | string, + replacement: string | ((substring: string, ...args: any[]) => string), + ): this; + /** + * Same as `s.replace`, but replace all matched strings instead of just one. + */ + replaceAll( + regex: RegExp | string, + replacement: string | ((substring: string, ...args: any[]) => string), + ): this; + + lastChar(): string; + lastLine(): string; + /** + * Returns true if the resulting source is empty (disregarding white space). + */ + isEmpty(): boolean; + length(): number; + + /** + * Indicates if the string has been changed. + */ + hasChanged(): boolean; + + original: string; + /** + * Returns the generated string. + */ + toString(): string; + + offset: number; +} diff --git a/frontend/node_modules/magic-string/dist/magic-string.es.mjs b/frontend/node_modules/magic-string/dist/magic-string.es.mjs new file mode 100644 index 0000000..c7999fc --- /dev/null +++ b/frontend/node_modules/magic-string/dist/magic-string.es.mjs @@ -0,0 +1,1588 @@ +import { encode } from '@jridgewell/sourcemap-codec'; + +class BitSet { + constructor(arg) { + this.bits = arg instanceof BitSet ? arg.bits.slice() : []; + } + + add(n) { + this.bits[n >> 5] |= 1 << (n & 31); + } + + has(n) { + return !!(this.bits[n >> 5] & (1 << (n & 31))); + } +} + +class Chunk { + constructor(start, end, content) { + this.start = start; + this.end = end; + this.original = content; + + this.intro = ''; + this.outro = ''; + + this.content = content; + this.storeName = false; + this.edited = false; + + { + this.previous = null; + this.next = null; + } + } + + appendLeft(content) { + this.outro += content; + } + + appendRight(content) { + this.intro = this.intro + content; + } + + clone() { + const chunk = new Chunk(this.start, this.end, this.original); + + chunk.intro = this.intro; + chunk.outro = this.outro; + chunk.content = this.content; + chunk.storeName = this.storeName; + chunk.edited = this.edited; + + return chunk; + } + + contains(index) { + return this.start < index && index < this.end; + } + + eachNext(fn) { + let chunk = this; + while (chunk) { + fn(chunk); + chunk = chunk.next; + } + } + + eachPrevious(fn) { + let chunk = this; + while (chunk) { + fn(chunk); + chunk = chunk.previous; + } + } + + edit(content, storeName, contentOnly) { + this.content = content; + if (!contentOnly) { + this.intro = ''; + this.outro = ''; + } + this.storeName = storeName; + + this.edited = true; + + return this; + } + + prependLeft(content) { + this.outro = content + this.outro; + } + + prependRight(content) { + this.intro = content + this.intro; + } + + reset() { + this.intro = ''; + this.outro = ''; + if (this.edited) { + this.content = this.original; + this.storeName = false; + this.edited = false; + } + } + + split(index) { + const sliceIndex = index - this.start; + + const originalBefore = this.original.slice(0, sliceIndex); + const originalAfter = this.original.slice(sliceIndex); + + this.original = originalBefore; + + const newChunk = new Chunk(index, this.end, originalAfter); + newChunk.outro = this.outro; + this.outro = ''; + + this.end = index; + + if (this.edited) { + // after split we should save the edit content record into the correct chunk + // to make sure sourcemap correct + // For example: + // ' test'.trim() + // split -> ' ' + 'test' + // ✔️ edit -> '' + 'test' + // ✖️ edit -> 'test' + '' + // TODO is this block necessary?... + newChunk.edit('', false); + this.content = ''; + } else { + this.content = originalBefore; + } + + newChunk.next = this.next; + if (newChunk.next) newChunk.next.previous = newChunk; + newChunk.previous = this; + this.next = newChunk; + + return newChunk; + } + + toString() { + return this.intro + this.content + this.outro; + } + + trimEnd(rx) { + this.outro = this.outro.replace(rx, ''); + if (this.outro.length) return true; + + const trimmed = this.content.replace(rx, ''); + + if (trimmed.length) { + if (trimmed !== this.content) { + this.split(this.start + trimmed.length).edit('', undefined, true); + if (this.edited) { + // save the change, if it has been edited + this.edit(trimmed, this.storeName, true); + } + } + return true; + } else { + this.edit('', undefined, true); + + this.intro = this.intro.replace(rx, ''); + if (this.intro.length) return true; + } + } + + trimStart(rx) { + this.intro = this.intro.replace(rx, ''); + if (this.intro.length) return true; + + const trimmed = this.content.replace(rx, ''); + + if (trimmed.length) { + if (trimmed !== this.content) { + const newChunk = this.split(this.end - trimmed.length); + if (this.edited) { + // save the change, if it has been edited + newChunk.edit(trimmed, this.storeName, true); + } + this.edit('', undefined, true); + } + return true; + } else { + this.edit('', undefined, true); + + this.outro = this.outro.replace(rx, ''); + if (this.outro.length) return true; + } + } +} + +function getBtoa() { + if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') { + return (str) => globalThis.btoa(unescape(encodeURIComponent(str))); + } else if (typeof Buffer === 'function') { + return (str) => Buffer.from(str, 'utf-8').toString('base64'); + } else { + return () => { + throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.'); + }; + } +} + +const btoa = /*#__PURE__*/ getBtoa(); + +class SourceMap { + constructor(properties) { + this.version = 3; + this.file = properties.file; + this.sources = properties.sources; + this.sourcesContent = properties.sourcesContent; + this.names = properties.names; + this.mappings = encode(properties.mappings); + if (typeof properties.x_google_ignoreList !== 'undefined') { + this.x_google_ignoreList = properties.x_google_ignoreList; + } + if (typeof properties.debugId !== 'undefined') { + this.debugId = properties.debugId; + } + } + + toString() { + return JSON.stringify(this); + } + + toUrl() { + return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString()); + } +} + +function guessIndent(code) { + const lines = code.split('\n'); + + const tabbed = lines.filter((line) => /^\t+/.test(line)); + const spaced = lines.filter((line) => /^ {2,}/.test(line)); + + if (tabbed.length === 0 && spaced.length === 0) { + return null; + } + + // More lines tabbed than spaced? Assume tabs, and + // default to tabs in the case of a tie (or nothing + // to go on) + if (tabbed.length >= spaced.length) { + return '\t'; + } + + // Otherwise, we need to guess the multiple + const min = spaced.reduce((previous, current) => { + const numSpaces = /^ +/.exec(current)[0].length; + return Math.min(numSpaces, previous); + }, Infinity); + + return new Array(min + 1).join(' '); +} + +function getRelativePath(from, to) { + const fromParts = from.split(/[/\\]/); + const toParts = to.split(/[/\\]/); + + fromParts.pop(); // get dirname + + while (fromParts[0] === toParts[0]) { + fromParts.shift(); + toParts.shift(); + } + + if (fromParts.length) { + let i = fromParts.length; + while (i--) fromParts[i] = '..'; + } + + return fromParts.concat(toParts).join('/'); +} + +const toString = Object.prototype.toString; + +function isObject(thing) { + return toString.call(thing) === '[object Object]'; +} + +function getLocator(source) { + const originalLines = source.split('\n'); + const lineOffsets = []; + + for (let i = 0, pos = 0; i < originalLines.length; i++) { + lineOffsets.push(pos); + pos += originalLines[i].length + 1; + } + + return function locate(index) { + let i = 0; + let j = lineOffsets.length; + while (i < j) { + const m = (i + j) >> 1; + if (index < lineOffsets[m]) { + j = m; + } else { + i = m + 1; + } + } + const line = i - 1; + const column = index - lineOffsets[line]; + return { line, column }; + }; +} + +const wordRegex = /\w/; + +class Mappings { + constructor(hires) { + this.hires = hires; + this.generatedCodeLine = 0; + this.generatedCodeColumn = 0; + this.raw = []; + this.rawSegments = this.raw[this.generatedCodeLine] = []; + this.pending = null; + } + + addEdit(sourceIndex, content, loc, nameIndex) { + if (content.length) { + const contentLengthMinusOne = content.length - 1; + let contentLineEnd = content.indexOf('\n', 0); + let previousContentLineEnd = -1; + // Loop through each line in the content and add a segment, but stop if the last line is empty, + // else code afterwards would fill one line too many + while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) { + const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; + if (nameIndex >= 0) { + segment.push(nameIndex); + } + this.rawSegments.push(segment); + + this.generatedCodeLine += 1; + this.raw[this.generatedCodeLine] = this.rawSegments = []; + this.generatedCodeColumn = 0; + + previousContentLineEnd = contentLineEnd; + contentLineEnd = content.indexOf('\n', contentLineEnd + 1); + } + + const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; + if (nameIndex >= 0) { + segment.push(nameIndex); + } + this.rawSegments.push(segment); + + this.advance(content.slice(previousContentLineEnd + 1)); + } else if (this.pending) { + this.rawSegments.push(this.pending); + this.advance(content); + } + + this.pending = null; + } + + addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) { + let originalCharIndex = chunk.start; + let first = true; + // when iterating each char, check if it's in a word boundary + let charInHiresBoundary = false; + + while (originalCharIndex < chunk.end) { + if (original[originalCharIndex] === '\n') { + loc.line += 1; + loc.column = 0; + this.generatedCodeLine += 1; + this.raw[this.generatedCodeLine] = this.rawSegments = []; + this.generatedCodeColumn = 0; + first = true; + charInHiresBoundary = false; + } else { + if (this.hires || first || sourcemapLocations.has(originalCharIndex)) { + const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; + + if (this.hires === 'boundary') { + // in hires "boundary", group segments per word boundary than per char + if (wordRegex.test(original[originalCharIndex])) { + // for first char in the boundary found, start the boundary by pushing a segment + if (!charInHiresBoundary) { + this.rawSegments.push(segment); + charInHiresBoundary = true; + } + } else { + // for non-word char, end the boundary by pushing a segment + this.rawSegments.push(segment); + charInHiresBoundary = false; + } + } else { + this.rawSegments.push(segment); + } + } + + loc.column += 1; + this.generatedCodeColumn += 1; + first = false; + } + + originalCharIndex += 1; + } + + this.pending = null; + } + + advance(str) { + if (!str) return; + + const lines = str.split('\n'); + + if (lines.length > 1) { + for (let i = 0; i < lines.length - 1; i++) { + this.generatedCodeLine++; + this.raw[this.generatedCodeLine] = this.rawSegments = []; + } + this.generatedCodeColumn = 0; + } + + this.generatedCodeColumn += lines[lines.length - 1].length; + } +} + +const n = '\n'; + +const warned = { + insertLeft: false, + insertRight: false, + storeName: false, +}; + +class MagicString { + constructor(string, options = {}) { + const chunk = new Chunk(0, string.length, string); + + Object.defineProperties(this, { + original: { writable: true, value: string }, + outro: { writable: true, value: '' }, + intro: { writable: true, value: '' }, + firstChunk: { writable: true, value: chunk }, + lastChunk: { writable: true, value: chunk }, + lastSearchedChunk: { writable: true, value: chunk }, + byStart: { writable: true, value: {} }, + byEnd: { writable: true, value: {} }, + filename: { writable: true, value: options.filename }, + indentExclusionRanges: { writable: true, value: options.indentExclusionRanges }, + sourcemapLocations: { writable: true, value: new BitSet() }, + storedNames: { writable: true, value: {} }, + indentStr: { writable: true, value: undefined }, + ignoreList: { writable: true, value: options.ignoreList }, + offset: { writable: true, value: options.offset || 0 }, + }); + + this.byStart[0] = chunk; + this.byEnd[string.length] = chunk; + } + + addSourcemapLocation(char) { + this.sourcemapLocations.add(char); + } + + append(content) { + if (typeof content !== 'string') throw new TypeError('outro content must be a string'); + + this.outro += content; + return this; + } + + appendLeft(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byEnd[index]; + + if (chunk) { + chunk.appendLeft(content); + } else { + this.intro += content; + } + return this; + } + + appendRight(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byStart[index]; + + if (chunk) { + chunk.appendRight(content); + } else { + this.outro += content; + } + return this; + } + + clone() { + const cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset }); + + let originalChunk = this.firstChunk; + let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone()); + + while (originalChunk) { + cloned.byStart[clonedChunk.start] = clonedChunk; + cloned.byEnd[clonedChunk.end] = clonedChunk; + + const nextOriginalChunk = originalChunk.next; + const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone(); + + if (nextClonedChunk) { + clonedChunk.next = nextClonedChunk; + nextClonedChunk.previous = clonedChunk; + + clonedChunk = nextClonedChunk; + } + + originalChunk = nextOriginalChunk; + } + + cloned.lastChunk = clonedChunk; + + if (this.indentExclusionRanges) { + cloned.indentExclusionRanges = this.indentExclusionRanges.slice(); + } + + cloned.sourcemapLocations = new BitSet(this.sourcemapLocations); + + cloned.intro = this.intro; + cloned.outro = this.outro; + + return cloned; + } + + generateDecodedMap(options) { + options = options || {}; + + const sourceIndex = 0; + const names = Object.keys(this.storedNames); + const mappings = new Mappings(options.hires); + + const locate = getLocator(this.original); + + if (this.intro) { + mappings.advance(this.intro); + } + + this.firstChunk.eachNext((chunk) => { + const loc = locate(chunk.start); + + if (chunk.intro.length) mappings.advance(chunk.intro); + + if (chunk.edited) { + mappings.addEdit( + sourceIndex, + chunk.content, + loc, + chunk.storeName ? names.indexOf(chunk.original) : -1, + ); + } else { + mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations); + } + + if (chunk.outro.length) mappings.advance(chunk.outro); + }); + + if (this.outro) { + mappings.advance(this.outro); + } + + return { + file: options.file ? options.file.split(/[/\\]/).pop() : undefined, + sources: [ + options.source ? getRelativePath(options.file || '', options.source) : options.file || '', + ], + sourcesContent: options.includeContent ? [this.original] : undefined, + names, + mappings: mappings.raw, + x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined, + }; + } + + generateMap(options) { + return new SourceMap(this.generateDecodedMap(options)); + } + + _ensureindentStr() { + if (this.indentStr === undefined) { + this.indentStr = guessIndent(this.original); + } + } + + _getRawIndentString() { + this._ensureindentStr(); + return this.indentStr; + } + + getIndentString() { + this._ensureindentStr(); + return this.indentStr === null ? '\t' : this.indentStr; + } + + indent(indentStr, options) { + const pattern = /^[^\r\n]/gm; + + if (isObject(indentStr)) { + options = indentStr; + indentStr = undefined; + } + + if (indentStr === undefined) { + this._ensureindentStr(); + indentStr = this.indentStr || '\t'; + } + + if (indentStr === '') return this; // noop + + options = options || {}; + + // Process exclusion ranges + const isExcluded = {}; + + if (options.exclude) { + const exclusions = + typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude; + exclusions.forEach((exclusion) => { + for (let i = exclusion[0]; i < exclusion[1]; i += 1) { + isExcluded[i] = true; + } + }); + } + + let shouldIndentNextCharacter = options.indentStart !== false; + const replacer = (match) => { + if (shouldIndentNextCharacter) return `${indentStr}${match}`; + shouldIndentNextCharacter = true; + return match; + }; + + this.intro = this.intro.replace(pattern, replacer); + + let charIndex = 0; + let chunk = this.firstChunk; + + while (chunk) { + const end = chunk.end; + + if (chunk.edited) { + if (!isExcluded[charIndex]) { + chunk.content = chunk.content.replace(pattern, replacer); + + if (chunk.content.length) { + shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n'; + } + } + } else { + charIndex = chunk.start; + + while (charIndex < end) { + if (!isExcluded[charIndex]) { + const char = this.original[charIndex]; + + if (char === '\n') { + shouldIndentNextCharacter = true; + } else if (char !== '\r' && shouldIndentNextCharacter) { + shouldIndentNextCharacter = false; + + if (charIndex === chunk.start) { + chunk.prependRight(indentStr); + } else { + this._splitChunk(chunk, charIndex); + chunk = chunk.next; + chunk.prependRight(indentStr); + } + } + } + + charIndex += 1; + } + } + + charIndex = chunk.end; + chunk = chunk.next; + } + + this.outro = this.outro.replace(pattern, replacer); + + return this; + } + + insert() { + throw new Error( + 'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)', + ); + } + + insertLeft(index, content) { + if (!warned.insertLeft) { + console.warn( + 'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead', + ); + warned.insertLeft = true; + } + + return this.appendLeft(index, content); + } + + insertRight(index, content) { + if (!warned.insertRight) { + console.warn( + 'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead', + ); + warned.insertRight = true; + } + + return this.prependRight(index, content); + } + + move(start, end, index) { + start = start + this.offset; + end = end + this.offset; + index = index + this.offset; + + if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself'); + + this._split(start); + this._split(end); + this._split(index); + + const first = this.byStart[start]; + const last = this.byEnd[end]; + + const oldLeft = first.previous; + const oldRight = last.next; + + const newRight = this.byStart[index]; + if (!newRight && last === this.lastChunk) return this; + const newLeft = newRight ? newRight.previous : this.lastChunk; + + if (oldLeft) oldLeft.next = oldRight; + if (oldRight) oldRight.previous = oldLeft; + + if (newLeft) newLeft.next = first; + if (newRight) newRight.previous = last; + + if (!first.previous) this.firstChunk = last.next; + if (!last.next) { + this.lastChunk = first.previous; + this.lastChunk.next = null; + } + + first.previous = newLeft; + last.next = newRight || null; + + if (!newLeft) this.firstChunk = first; + if (!newRight) this.lastChunk = last; + return this; + } + + overwrite(start, end, content, options) { + options = options || {}; + return this.update(start, end, content, { ...options, overwrite: !options.contentOnly }); + } + + update(start, end, content, options) { + start = start + this.offset; + end = end + this.offset; + + if (typeof content !== 'string') throw new TypeError('replacement content must be a string'); + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + if (end > this.original.length) throw new Error('end is out of bounds'); + if (start === end) + throw new Error( + 'Cannot overwrite a zero-length range – use appendLeft or prependRight instead', + ); + + this._split(start); + this._split(end); + + if (options === true) { + if (!warned.storeName) { + console.warn( + 'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string', + ); + warned.storeName = true; + } + + options = { storeName: true }; + } + const storeName = options !== undefined ? options.storeName : false; + const overwrite = options !== undefined ? options.overwrite : false; + + if (storeName) { + const original = this.original.slice(start, end); + Object.defineProperty(this.storedNames, original, { + writable: true, + value: true, + enumerable: true, + }); + } + + const first = this.byStart[start]; + const last = this.byEnd[end]; + + if (first) { + let chunk = first; + while (chunk !== last) { + if (chunk.next !== this.byStart[chunk.end]) { + throw new Error('Cannot overwrite across a split point'); + } + chunk = chunk.next; + chunk.edit('', false); + } + + first.edit(content, storeName, !overwrite); + } else { + // must be inserting at the end + const newChunk = new Chunk(start, end, '').edit(content, storeName); + + // TODO last chunk in the array may not be the last chunk, if it's moved... + last.next = newChunk; + newChunk.previous = last; + } + return this; + } + + prepend(content) { + if (typeof content !== 'string') throw new TypeError('outro content must be a string'); + + this.intro = content + this.intro; + return this; + } + + prependLeft(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byEnd[index]; + + if (chunk) { + chunk.prependLeft(content); + } else { + this.intro = content + this.intro; + } + return this; + } + + prependRight(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byStart[index]; + + if (chunk) { + chunk.prependRight(content); + } else { + this.outro = content + this.outro; + } + return this; + } + + remove(start, end) { + start = start + this.offset; + end = end + this.offset; + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + if (start === end) return this; + + if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds'); + if (start > end) throw new Error('end must be greater than start'); + + this._split(start); + this._split(end); + + let chunk = this.byStart[start]; + + while (chunk) { + chunk.intro = ''; + chunk.outro = ''; + chunk.edit(''); + + chunk = end > chunk.end ? this.byStart[chunk.end] : null; + } + return this; + } + + reset(start, end) { + start = start + this.offset; + end = end + this.offset; + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + if (start === end) return this; + + if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds'); + if (start > end) throw new Error('end must be greater than start'); + + this._split(start); + this._split(end); + + let chunk = this.byStart[start]; + + while (chunk) { + chunk.reset(); + + chunk = end > chunk.end ? this.byStart[chunk.end] : null; + } + return this; + } + + lastChar() { + if (this.outro.length) return this.outro[this.outro.length - 1]; + let chunk = this.lastChunk; + do { + if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1]; + if (chunk.content.length) return chunk.content[chunk.content.length - 1]; + if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1]; + } while ((chunk = chunk.previous)); + if (this.intro.length) return this.intro[this.intro.length - 1]; + return ''; + } + + lastLine() { + let lineIndex = this.outro.lastIndexOf(n); + if (lineIndex !== -1) return this.outro.substr(lineIndex + 1); + let lineStr = this.outro; + let chunk = this.lastChunk; + do { + if (chunk.outro.length > 0) { + lineIndex = chunk.outro.lastIndexOf(n); + if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr; + lineStr = chunk.outro + lineStr; + } + + if (chunk.content.length > 0) { + lineIndex = chunk.content.lastIndexOf(n); + if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr; + lineStr = chunk.content + lineStr; + } + + if (chunk.intro.length > 0) { + lineIndex = chunk.intro.lastIndexOf(n); + if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr; + lineStr = chunk.intro + lineStr; + } + } while ((chunk = chunk.previous)); + lineIndex = this.intro.lastIndexOf(n); + if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr; + return this.intro + lineStr; + } + + slice(start = 0, end = this.original.length - this.offset) { + start = start + this.offset; + end = end + this.offset; + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + let result = ''; + + // find start chunk + let chunk = this.firstChunk; + while (chunk && (chunk.start > start || chunk.end <= start)) { + // found end chunk before start + if (chunk.start < end && chunk.end >= end) { + return result; + } + + chunk = chunk.next; + } + + if (chunk && chunk.edited && chunk.start !== start) + throw new Error(`Cannot use replaced character ${start} as slice start anchor.`); + + const startChunk = chunk; + while (chunk) { + if (chunk.intro && (startChunk !== chunk || chunk.start === start)) { + result += chunk.intro; + } + + const containsEnd = chunk.start < end && chunk.end >= end; + if (containsEnd && chunk.edited && chunk.end !== end) + throw new Error(`Cannot use replaced character ${end} as slice end anchor.`); + + const sliceStart = startChunk === chunk ? start - chunk.start : 0; + const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length; + + result += chunk.content.slice(sliceStart, sliceEnd); + + if (chunk.outro && (!containsEnd || chunk.end === end)) { + result += chunk.outro; + } + + if (containsEnd) { + break; + } + + chunk = chunk.next; + } + + return result; + } + + // TODO deprecate this? not really very useful + snip(start, end) { + const clone = this.clone(); + clone.remove(0, start); + clone.remove(end, clone.original.length); + + return clone; + } + + _split(index) { + if (this.byStart[index] || this.byEnd[index]) return; + + let chunk = this.lastSearchedChunk; + let previousChunk = chunk; + const searchForward = index > chunk.end; + + while (chunk) { + if (chunk.contains(index)) return this._splitChunk(chunk, index); + + chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start]; + + // Prevent infinite loop (e.g. via empty chunks, where start === end) + if (chunk === previousChunk) return; + + previousChunk = chunk; + } + } + + _splitChunk(chunk, index) { + if (chunk.edited && chunk.content.length) { + // zero-length edited chunks are a special case (overlapping replacements) + const loc = getLocator(this.original)(index); + throw new Error( + `Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`, + ); + } + + const newChunk = chunk.split(index); + + this.byEnd[index] = chunk; + this.byStart[index] = newChunk; + this.byEnd[newChunk.end] = newChunk; + + if (chunk === this.lastChunk) this.lastChunk = newChunk; + + this.lastSearchedChunk = chunk; + return true; + } + + toString() { + let str = this.intro; + + let chunk = this.firstChunk; + while (chunk) { + str += chunk.toString(); + chunk = chunk.next; + } + + return str + this.outro; + } + + isEmpty() { + let chunk = this.firstChunk; + do { + if ( + (chunk.intro.length && chunk.intro.trim()) || + (chunk.content.length && chunk.content.trim()) || + (chunk.outro.length && chunk.outro.trim()) + ) + return false; + } while ((chunk = chunk.next)); + return true; + } + + length() { + let chunk = this.firstChunk; + let length = 0; + do { + length += chunk.intro.length + chunk.content.length + chunk.outro.length; + } while ((chunk = chunk.next)); + return length; + } + + trimLines() { + return this.trim('[\\r\\n]'); + } + + trim(charType) { + return this.trimStart(charType).trimEnd(charType); + } + + trimEndAborted(charType) { + const rx = new RegExp((charType || '\\s') + '+$'); + + this.outro = this.outro.replace(rx, ''); + if (this.outro.length) return true; + + let chunk = this.lastChunk; + + do { + const end = chunk.end; + const aborted = chunk.trimEnd(rx); + + // if chunk was trimmed, we have a new lastChunk + if (chunk.end !== end) { + if (this.lastChunk === chunk) { + this.lastChunk = chunk.next; + } + + this.byEnd[chunk.end] = chunk; + this.byStart[chunk.next.start] = chunk.next; + this.byEnd[chunk.next.end] = chunk.next; + } + + if (aborted) return true; + chunk = chunk.previous; + } while (chunk); + + return false; + } + + trimEnd(charType) { + this.trimEndAborted(charType); + return this; + } + trimStartAborted(charType) { + const rx = new RegExp('^' + (charType || '\\s') + '+'); + + this.intro = this.intro.replace(rx, ''); + if (this.intro.length) return true; + + let chunk = this.firstChunk; + + do { + const end = chunk.end; + const aborted = chunk.trimStart(rx); + + if (chunk.end !== end) { + // special case... + if (chunk === this.lastChunk) this.lastChunk = chunk.next; + + this.byEnd[chunk.end] = chunk; + this.byStart[chunk.next.start] = chunk.next; + this.byEnd[chunk.next.end] = chunk.next; + } + + if (aborted) return true; + chunk = chunk.next; + } while (chunk); + + return false; + } + + trimStart(charType) { + this.trimStartAborted(charType); + return this; + } + + hasChanged() { + return this.original !== this.toString(); + } + + _replaceRegexp(searchValue, replacement) { + function getReplacement(match, str) { + if (typeof replacement === 'string') { + return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => { + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter + if (i === '$') return '$'; + if (i === '&') return match[0]; + const num = +i; + if (num < match.length) return match[+i]; + return `$${i}`; + }); + } else { + return replacement(...match, match.index, str, match.groups); + } + } + function matchAll(re, str) { + let match; + const matches = []; + while ((match = re.exec(str))) { + matches.push(match); + } + return matches; + } + if (searchValue.global) { + const matches = matchAll(searchValue, this.original); + matches.forEach((match) => { + if (match.index != null) { + const replacement = getReplacement(match, this.original); + if (replacement !== match[0]) { + this.overwrite(match.index, match.index + match[0].length, replacement); + } + } + }); + } else { + const match = this.original.match(searchValue); + if (match && match.index != null) { + const replacement = getReplacement(match, this.original); + if (replacement !== match[0]) { + this.overwrite(match.index, match.index + match[0].length, replacement); + } + } + } + return this; + } + + _replaceString(string, replacement) { + const { original } = this; + const index = original.indexOf(string); + + if (index !== -1) { + if (typeof replacement === 'function') { + replacement = replacement(string, index, original); + } + if (string !== replacement) { + this.overwrite(index, index + string.length, replacement); + } + } + + return this; + } + + replace(searchValue, replacement) { + if (typeof searchValue === 'string') { + return this._replaceString(searchValue, replacement); + } + + return this._replaceRegexp(searchValue, replacement); + } + + _replaceAllString(string, replacement) { + const { original } = this; + const stringLength = string.length; + for ( + let index = original.indexOf(string); + index !== -1; + index = original.indexOf(string, index + stringLength) + ) { + const previous = original.slice(index, index + stringLength); + let _replacement = replacement; + if (typeof replacement === 'function') { + _replacement = replacement(previous, index, original); + } + if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement); + } + + return this; + } + + replaceAll(searchValue, replacement) { + if (typeof searchValue === 'string') { + return this._replaceAllString(searchValue, replacement); + } + + if (!searchValue.global) { + throw new TypeError( + 'MagicString.prototype.replaceAll called with a non-global RegExp argument', + ); + } + + return this._replaceRegexp(searchValue, replacement); + } +} + +const hasOwnProp = Object.prototype.hasOwnProperty; + +class Bundle { + constructor(options = {}) { + this.intro = options.intro || ''; + this.separator = options.separator !== undefined ? options.separator : '\n'; + this.sources = []; + this.uniqueSources = []; + this.uniqueSourceIndexByFilename = {}; + } + + addSource(source) { + if (source instanceof MagicString) { + return this.addSource({ + content: source, + filename: source.filename, + separator: this.separator, + }); + } + + if (!isObject(source) || !source.content) { + throw new Error( + 'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`', + ); + } + + ['filename', 'ignoreList', 'indentExclusionRanges', 'separator'].forEach((option) => { + if (!hasOwnProp.call(source, option)) source[option] = source.content[option]; + }); + + if (source.separator === undefined) { + // TODO there's a bunch of this sort of thing, needs cleaning up + source.separator = this.separator; + } + + if (source.filename) { + if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) { + this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length; + this.uniqueSources.push({ filename: source.filename, content: source.content.original }); + } else { + const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]]; + if (source.content.original !== uniqueSource.content) { + throw new Error(`Illegal source: same filename (${source.filename}), different contents`); + } + } + } + + this.sources.push(source); + return this; + } + + append(str, options) { + this.addSource({ + content: new MagicString(str), + separator: (options && options.separator) || '', + }); + + return this; + } + + clone() { + const bundle = new Bundle({ + intro: this.intro, + separator: this.separator, + }); + + this.sources.forEach((source) => { + bundle.addSource({ + filename: source.filename, + content: source.content.clone(), + separator: source.separator, + }); + }); + + return bundle; + } + + generateDecodedMap(options = {}) { + const names = []; + let x_google_ignoreList = undefined; + this.sources.forEach((source) => { + Object.keys(source.content.storedNames).forEach((name) => { + if (!~names.indexOf(name)) names.push(name); + }); + }); + + const mappings = new Mappings(options.hires); + + if (this.intro) { + mappings.advance(this.intro); + } + + this.sources.forEach((source, i) => { + if (i > 0) { + mappings.advance(this.separator); + } + + const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1; + const magicString = source.content; + const locate = getLocator(magicString.original); + + if (magicString.intro) { + mappings.advance(magicString.intro); + } + + magicString.firstChunk.eachNext((chunk) => { + const loc = locate(chunk.start); + + if (chunk.intro.length) mappings.advance(chunk.intro); + + if (source.filename) { + if (chunk.edited) { + mappings.addEdit( + sourceIndex, + chunk.content, + loc, + chunk.storeName ? names.indexOf(chunk.original) : -1, + ); + } else { + mappings.addUneditedChunk( + sourceIndex, + chunk, + magicString.original, + loc, + magicString.sourcemapLocations, + ); + } + } else { + mappings.advance(chunk.content); + } + + if (chunk.outro.length) mappings.advance(chunk.outro); + }); + + if (magicString.outro) { + mappings.advance(magicString.outro); + } + + if (source.ignoreList && sourceIndex !== -1) { + if (x_google_ignoreList === undefined) { + x_google_ignoreList = []; + } + x_google_ignoreList.push(sourceIndex); + } + }); + + return { + file: options.file ? options.file.split(/[/\\]/).pop() : undefined, + sources: this.uniqueSources.map((source) => { + return options.file ? getRelativePath(options.file, source.filename) : source.filename; + }), + sourcesContent: this.uniqueSources.map((source) => { + return options.includeContent ? source.content : null; + }), + names, + mappings: mappings.raw, + x_google_ignoreList, + }; + } + + generateMap(options) { + return new SourceMap(this.generateDecodedMap(options)); + } + + getIndentString() { + const indentStringCounts = {}; + + this.sources.forEach((source) => { + const indentStr = source.content._getRawIndentString(); + + if (indentStr === null) return; + + if (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0; + indentStringCounts[indentStr] += 1; + }); + + return ( + Object.keys(indentStringCounts).sort((a, b) => { + return indentStringCounts[a] - indentStringCounts[b]; + })[0] || '\t' + ); + } + + indent(indentStr) { + if (!arguments.length) { + indentStr = this.getIndentString(); + } + + if (indentStr === '') return this; // noop + + let trailingNewline = !this.intro || this.intro.slice(-1) === '\n'; + + this.sources.forEach((source, i) => { + const separator = source.separator !== undefined ? source.separator : this.separator; + const indentStart = trailingNewline || (i > 0 && /\r?\n$/.test(separator)); + + source.content.indent(indentStr, { + exclude: source.indentExclusionRanges, + indentStart, //: trailingNewline || /\r?\n$/.test( separator ) //true///\r?\n/.test( separator ) + }); + + trailingNewline = source.content.lastChar() === '\n'; + }); + + if (this.intro) { + this.intro = + indentStr + + this.intro.replace(/^[^\n]/gm, (match, index) => { + return index > 0 ? indentStr + match : match; + }); + } + + return this; + } + + prepend(str) { + this.intro = str + this.intro; + return this; + } + + toString() { + const body = this.sources + .map((source, i) => { + const separator = source.separator !== undefined ? source.separator : this.separator; + const str = (i > 0 ? separator : '') + source.content.toString(); + + return str; + }) + .join(''); + + return this.intro + body; + } + + isEmpty() { + if (this.intro.length && this.intro.trim()) return false; + if (this.sources.some((source) => !source.content.isEmpty())) return false; + return true; + } + + length() { + return this.sources.reduce( + (length, source) => length + source.content.length(), + this.intro.length, + ); + } + + trimLines() { + return this.trim('[\\r\\n]'); + } + + trim(charType) { + return this.trimStart(charType).trimEnd(charType); + } + + trimStart(charType) { + const rx = new RegExp('^' + (charType || '\\s') + '+'); + this.intro = this.intro.replace(rx, ''); + + if (!this.intro) { + let source; + let i = 0; + + do { + source = this.sources[i++]; + if (!source) { + break; + } + } while (!source.content.trimStartAborted(charType)); + } + + return this; + } + + trimEnd(charType) { + const rx = new RegExp((charType || '\\s') + '+$'); + + let source; + let i = this.sources.length - 1; + + do { + source = this.sources[i--]; + if (!source) { + this.intro = this.intro.replace(rx, ''); + break; + } + } while (!source.content.trimEndAborted(charType)); + + return this; + } +} + +export { Bundle, SourceMap, MagicString as default }; +//# sourceMappingURL=magic-string.es.mjs.map diff --git a/frontend/node_modules/magic-string/dist/magic-string.es.mjs.map b/frontend/node_modules/magic-string/dist/magic-string.es.mjs.map new file mode 100644 index 0000000..a60bcc8 --- /dev/null +++ b/frontend/node_modules/magic-string/dist/magic-string.es.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"magic-string.es.mjs","sources":["../src/BitSet.js","../src/Chunk.js","../src/SourceMap.js","../src/utils/guessIndent.js","../src/utils/getRelativePath.js","../src/utils/isObject.js","../src/utils/getLocator.js","../src/utils/Mappings.js","../src/MagicString.js","../src/Bundle.js"],"sourcesContent":["export default class BitSet {\n\tconstructor(arg) {\n\t\tthis.bits = arg instanceof BitSet ? arg.bits.slice() : [];\n\t}\n\n\tadd(n) {\n\t\tthis.bits[n >> 5] |= 1 << (n & 31);\n\t}\n\n\thas(n) {\n\t\treturn !!(this.bits[n >> 5] & (1 << (n & 31)));\n\t}\n}\n","export default class Chunk {\n\tconstructor(start, end, content) {\n\t\tthis.start = start;\n\t\tthis.end = end;\n\t\tthis.original = content;\n\n\t\tthis.intro = '';\n\t\tthis.outro = '';\n\n\t\tthis.content = content;\n\t\tthis.storeName = false;\n\t\tthis.edited = false;\n\n\t\tif (DEBUG) {\n\t\t\t// we make these non-enumerable, for sanity while debugging\n\t\t\tObject.defineProperties(this, {\n\t\t\t\tprevious: { writable: true, value: null },\n\t\t\t\tnext: { writable: true, value: null },\n\t\t\t});\n\t\t} else {\n\t\t\tthis.previous = null;\n\t\t\tthis.next = null;\n\t\t}\n\t}\n\n\tappendLeft(content) {\n\t\tthis.outro += content;\n\t}\n\n\tappendRight(content) {\n\t\tthis.intro = this.intro + content;\n\t}\n\n\tclone() {\n\t\tconst chunk = new Chunk(this.start, this.end, this.original);\n\n\t\tchunk.intro = this.intro;\n\t\tchunk.outro = this.outro;\n\t\tchunk.content = this.content;\n\t\tchunk.storeName = this.storeName;\n\t\tchunk.edited = this.edited;\n\n\t\treturn chunk;\n\t}\n\n\tcontains(index) {\n\t\treturn this.start < index && index < this.end;\n\t}\n\n\teachNext(fn) {\n\t\tlet chunk = this;\n\t\twhile (chunk) {\n\t\t\tfn(chunk);\n\t\t\tchunk = chunk.next;\n\t\t}\n\t}\n\n\teachPrevious(fn) {\n\t\tlet chunk = this;\n\t\twhile (chunk) {\n\t\t\tfn(chunk);\n\t\t\tchunk = chunk.previous;\n\t\t}\n\t}\n\n\tedit(content, storeName, contentOnly) {\n\t\tthis.content = content;\n\t\tif (!contentOnly) {\n\t\t\tthis.intro = '';\n\t\t\tthis.outro = '';\n\t\t}\n\t\tthis.storeName = storeName;\n\n\t\tthis.edited = true;\n\n\t\treturn this;\n\t}\n\n\tprependLeft(content) {\n\t\tthis.outro = content + this.outro;\n\t}\n\n\tprependRight(content) {\n\t\tthis.intro = content + this.intro;\n\t}\n\n\treset() {\n\t\tthis.intro = '';\n\t\tthis.outro = '';\n\t\tif (this.edited) {\n\t\t\tthis.content = this.original;\n\t\t\tthis.storeName = false;\n\t\t\tthis.edited = false;\n\t\t}\n\t}\n\n\tsplit(index) {\n\t\tconst sliceIndex = index - this.start;\n\n\t\tconst originalBefore = this.original.slice(0, sliceIndex);\n\t\tconst originalAfter = this.original.slice(sliceIndex);\n\n\t\tthis.original = originalBefore;\n\n\t\tconst newChunk = new Chunk(index, this.end, originalAfter);\n\t\tnewChunk.outro = this.outro;\n\t\tthis.outro = '';\n\n\t\tthis.end = index;\n\n\t\tif (this.edited) {\n\t\t\t// after split we should save the edit content record into the correct chunk\n\t\t\t// to make sure sourcemap correct\n\t\t\t// For example:\n\t\t\t// ' test'.trim()\n\t\t\t// split -> ' ' + 'test'\n\t\t\t// ✔️ edit -> '' + 'test'\n\t\t\t// ✖️ edit -> 'test' + ''\n\t\t\t// TODO is this block necessary?...\n\t\t\tnewChunk.edit('', false);\n\t\t\tthis.content = '';\n\t\t} else {\n\t\t\tthis.content = originalBefore;\n\t\t}\n\n\t\tnewChunk.next = this.next;\n\t\tif (newChunk.next) newChunk.next.previous = newChunk;\n\t\tnewChunk.previous = this;\n\t\tthis.next = newChunk;\n\n\t\treturn newChunk;\n\t}\n\n\ttoString() {\n\t\treturn this.intro + this.content + this.outro;\n\t}\n\n\ttrimEnd(rx) {\n\t\tthis.outro = this.outro.replace(rx, '');\n\t\tif (this.outro.length) return true;\n\n\t\tconst trimmed = this.content.replace(rx, '');\n\n\t\tif (trimmed.length) {\n\t\t\tif (trimmed !== this.content) {\n\t\t\t\tthis.split(this.start + trimmed.length).edit('', undefined, true);\n\t\t\t\tif (this.edited) {\n\t\t\t\t\t// save the change, if it has been edited\n\t\t\t\t\tthis.edit(trimmed, this.storeName, true);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} else {\n\t\t\tthis.edit('', undefined, true);\n\n\t\t\tthis.intro = this.intro.replace(rx, '');\n\t\t\tif (this.intro.length) return true;\n\t\t}\n\t}\n\n\ttrimStart(rx) {\n\t\tthis.intro = this.intro.replace(rx, '');\n\t\tif (this.intro.length) return true;\n\n\t\tconst trimmed = this.content.replace(rx, '');\n\n\t\tif (trimmed.length) {\n\t\t\tif (trimmed !== this.content) {\n\t\t\t\tconst newChunk = this.split(this.end - trimmed.length);\n\t\t\t\tif (this.edited) {\n\t\t\t\t\t// save the change, if it has been edited\n\t\t\t\t\tnewChunk.edit(trimmed, this.storeName, true);\n\t\t\t\t}\n\t\t\t\tthis.edit('', undefined, true);\n\t\t\t}\n\t\t\treturn true;\n\t\t} else {\n\t\t\tthis.edit('', undefined, true);\n\n\t\t\tthis.outro = this.outro.replace(rx, '');\n\t\t\tif (this.outro.length) return true;\n\t\t}\n\t}\n}\n","import { encode } from '@jridgewell/sourcemap-codec';\n\nfunction getBtoa() {\n\tif (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {\n\t\treturn (str) => globalThis.btoa(unescape(encodeURIComponent(str)));\n\t} else if (typeof Buffer === 'function') {\n\t\treturn (str) => Buffer.from(str, 'utf-8').toString('base64');\n\t} else {\n\t\treturn () => {\n\t\t\tthrow new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');\n\t\t};\n\t}\n}\n\nconst btoa = /*#__PURE__*/ getBtoa();\n\nexport default class SourceMap {\n\tconstructor(properties) {\n\t\tthis.version = 3;\n\t\tthis.file = properties.file;\n\t\tthis.sources = properties.sources;\n\t\tthis.sourcesContent = properties.sourcesContent;\n\t\tthis.names = properties.names;\n\t\tthis.mappings = encode(properties.mappings);\n\t\tif (typeof properties.x_google_ignoreList !== 'undefined') {\n\t\t\tthis.x_google_ignoreList = properties.x_google_ignoreList;\n\t\t}\n\t\tif (typeof properties.debugId !== 'undefined') {\n\t\t\tthis.debugId = properties.debugId;\n\t\t}\n\t}\n\n\ttoString() {\n\t\treturn JSON.stringify(this);\n\t}\n\n\ttoUrl() {\n\t\treturn 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());\n\t}\n}\n","export default function guessIndent(code) {\n\tconst lines = code.split('\\n');\n\n\tconst tabbed = lines.filter((line) => /^\\t+/.test(line));\n\tconst spaced = lines.filter((line) => /^ {2,}/.test(line));\n\n\tif (tabbed.length === 0 && spaced.length === 0) {\n\t\treturn null;\n\t}\n\n\t// More lines tabbed than spaced? Assume tabs, and\n\t// default to tabs in the case of a tie (or nothing\n\t// to go on)\n\tif (tabbed.length >= spaced.length) {\n\t\treturn '\\t';\n\t}\n\n\t// Otherwise, we need to guess the multiple\n\tconst min = spaced.reduce((previous, current) => {\n\t\tconst numSpaces = /^ +/.exec(current)[0].length;\n\t\treturn Math.min(numSpaces, previous);\n\t}, Infinity);\n\n\treturn new Array(min + 1).join(' ');\n}\n","export default function getRelativePath(from, to) {\n\tconst fromParts = from.split(/[/\\\\]/);\n\tconst toParts = to.split(/[/\\\\]/);\n\n\tfromParts.pop(); // get dirname\n\n\twhile (fromParts[0] === toParts[0]) {\n\t\tfromParts.shift();\n\t\ttoParts.shift();\n\t}\n\n\tif (fromParts.length) {\n\t\tlet i = fromParts.length;\n\t\twhile (i--) fromParts[i] = '..';\n\t}\n\n\treturn fromParts.concat(toParts).join('/');\n}\n","const toString = Object.prototype.toString;\n\nexport default function isObject(thing) {\n\treturn toString.call(thing) === '[object Object]';\n}\n","export default function getLocator(source) {\n\tconst originalLines = source.split('\\n');\n\tconst lineOffsets = [];\n\n\tfor (let i = 0, pos = 0; i < originalLines.length; i++) {\n\t\tlineOffsets.push(pos);\n\t\tpos += originalLines[i].length + 1;\n\t}\n\n\treturn function locate(index) {\n\t\tlet i = 0;\n\t\tlet j = lineOffsets.length;\n\t\twhile (i < j) {\n\t\t\tconst m = (i + j) >> 1;\n\t\t\tif (index < lineOffsets[m]) {\n\t\t\t\tj = m;\n\t\t\t} else {\n\t\t\t\ti = m + 1;\n\t\t\t}\n\t\t}\n\t\tconst line = i - 1;\n\t\tconst column = index - lineOffsets[line];\n\t\treturn { line, column };\n\t};\n}\n","const wordRegex = /\\w/;\n\nexport default class Mappings {\n\tconstructor(hires) {\n\t\tthis.hires = hires;\n\t\tthis.generatedCodeLine = 0;\n\t\tthis.generatedCodeColumn = 0;\n\t\tthis.raw = [];\n\t\tthis.rawSegments = this.raw[this.generatedCodeLine] = [];\n\t\tthis.pending = null;\n\t}\n\n\taddEdit(sourceIndex, content, loc, nameIndex) {\n\t\tif (content.length) {\n\t\t\tconst contentLengthMinusOne = content.length - 1;\n\t\t\tlet contentLineEnd = content.indexOf('\\n', 0);\n\t\t\tlet previousContentLineEnd = -1;\n\t\t\t// Loop through each line in the content and add a segment, but stop if the last line is empty,\n\t\t\t// else code afterwards would fill one line too many\n\t\t\twhile (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {\n\t\t\t\tconst segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];\n\t\t\t\tif (nameIndex >= 0) {\n\t\t\t\t\tsegment.push(nameIndex);\n\t\t\t\t}\n\t\t\t\tthis.rawSegments.push(segment);\n\n\t\t\t\tthis.generatedCodeLine += 1;\n\t\t\t\tthis.raw[this.generatedCodeLine] = this.rawSegments = [];\n\t\t\t\tthis.generatedCodeColumn = 0;\n\n\t\t\t\tpreviousContentLineEnd = contentLineEnd;\n\t\t\t\tcontentLineEnd = content.indexOf('\\n', contentLineEnd + 1);\n\t\t\t}\n\n\t\t\tconst segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];\n\t\t\tif (nameIndex >= 0) {\n\t\t\t\tsegment.push(nameIndex);\n\t\t\t}\n\t\t\tthis.rawSegments.push(segment);\n\n\t\t\tthis.advance(content.slice(previousContentLineEnd + 1));\n\t\t} else if (this.pending) {\n\t\t\tthis.rawSegments.push(this.pending);\n\t\t\tthis.advance(content);\n\t\t}\n\n\t\tthis.pending = null;\n\t}\n\n\taddUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {\n\t\tlet originalCharIndex = chunk.start;\n\t\tlet first = true;\n\t\t// when iterating each char, check if it's in a word boundary\n\t\tlet charInHiresBoundary = false;\n\n\t\twhile (originalCharIndex < chunk.end) {\n\t\t\tif (original[originalCharIndex] === '\\n') {\n\t\t\t\tloc.line += 1;\n\t\t\t\tloc.column = 0;\n\t\t\t\tthis.generatedCodeLine += 1;\n\t\t\t\tthis.raw[this.generatedCodeLine] = this.rawSegments = [];\n\t\t\t\tthis.generatedCodeColumn = 0;\n\t\t\t\tfirst = true;\n\t\t\t\tcharInHiresBoundary = false;\n\t\t\t} else {\n\t\t\t\tif (this.hires || first || sourcemapLocations.has(originalCharIndex)) {\n\t\t\t\t\tconst segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];\n\n\t\t\t\t\tif (this.hires === 'boundary') {\n\t\t\t\t\t\t// in hires \"boundary\", group segments per word boundary than per char\n\t\t\t\t\t\tif (wordRegex.test(original[originalCharIndex])) {\n\t\t\t\t\t\t\t// for first char in the boundary found, start the boundary by pushing a segment\n\t\t\t\t\t\t\tif (!charInHiresBoundary) {\n\t\t\t\t\t\t\t\tthis.rawSegments.push(segment);\n\t\t\t\t\t\t\t\tcharInHiresBoundary = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// for non-word char, end the boundary by pushing a segment\n\t\t\t\t\t\t\tthis.rawSegments.push(segment);\n\t\t\t\t\t\t\tcharInHiresBoundary = false;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.rawSegments.push(segment);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tloc.column += 1;\n\t\t\t\tthis.generatedCodeColumn += 1;\n\t\t\t\tfirst = false;\n\t\t\t}\n\n\t\t\toriginalCharIndex += 1;\n\t\t}\n\n\t\tthis.pending = null;\n\t}\n\n\tadvance(str) {\n\t\tif (!str) return;\n\n\t\tconst lines = str.split('\\n');\n\n\t\tif (lines.length > 1) {\n\t\t\tfor (let i = 0; i < lines.length - 1; i++) {\n\t\t\t\tthis.generatedCodeLine++;\n\t\t\t\tthis.raw[this.generatedCodeLine] = this.rawSegments = [];\n\t\t\t}\n\t\t\tthis.generatedCodeColumn = 0;\n\t\t}\n\n\t\tthis.generatedCodeColumn += lines[lines.length - 1].length;\n\t}\n}\n","import BitSet from './BitSet.js';\nimport Chunk from './Chunk.js';\nimport SourceMap from './SourceMap.js';\nimport guessIndent from './utils/guessIndent.js';\nimport getRelativePath from './utils/getRelativePath.js';\nimport isObject from './utils/isObject.js';\nimport getLocator from './utils/getLocator.js';\nimport Mappings from './utils/Mappings.js';\nimport Stats from './utils/Stats.js';\n\nconst n = '\\n';\n\nconst warned = {\n\tinsertLeft: false,\n\tinsertRight: false,\n\tstoreName: false,\n};\n\nexport default class MagicString {\n\tconstructor(string, options = {}) {\n\t\tconst chunk = new Chunk(0, string.length, string);\n\n\t\tObject.defineProperties(this, {\n\t\t\toriginal: { writable: true, value: string },\n\t\t\toutro: { writable: true, value: '' },\n\t\t\tintro: { writable: true, value: '' },\n\t\t\tfirstChunk: { writable: true, value: chunk },\n\t\t\tlastChunk: { writable: true, value: chunk },\n\t\t\tlastSearchedChunk: { writable: true, value: chunk },\n\t\t\tbyStart: { writable: true, value: {} },\n\t\t\tbyEnd: { writable: true, value: {} },\n\t\t\tfilename: { writable: true, value: options.filename },\n\t\t\tindentExclusionRanges: { writable: true, value: options.indentExclusionRanges },\n\t\t\tsourcemapLocations: { writable: true, value: new BitSet() },\n\t\t\tstoredNames: { writable: true, value: {} },\n\t\t\tindentStr: { writable: true, value: undefined },\n\t\t\tignoreList: { writable: true, value: options.ignoreList },\n\t\t\toffset: { writable: true, value: options.offset || 0 },\n\t\t});\n\n\t\tif (DEBUG) {\n\t\t\tObject.defineProperty(this, 'stats', { value: new Stats() });\n\t\t}\n\n\t\tthis.byStart[0] = chunk;\n\t\tthis.byEnd[string.length] = chunk;\n\t}\n\n\taddSourcemapLocation(char) {\n\t\tthis.sourcemapLocations.add(char);\n\t}\n\n\tappend(content) {\n\t\tif (typeof content !== 'string') throw new TypeError('outro content must be a string');\n\n\t\tthis.outro += content;\n\t\treturn this;\n\t}\n\n\tappendLeft(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('appendLeft');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byEnd[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.appendLeft(content);\n\t\t} else {\n\t\t\tthis.intro += content;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('appendLeft');\n\t\treturn this;\n\t}\n\n\tappendRight(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('appendRight');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byStart[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.appendRight(content);\n\t\t} else {\n\t\t\tthis.outro += content;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('appendRight');\n\t\treturn this;\n\t}\n\n\tclone() {\n\t\tconst cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset });\n\n\t\tlet originalChunk = this.firstChunk;\n\t\tlet clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());\n\n\t\twhile (originalChunk) {\n\t\t\tcloned.byStart[clonedChunk.start] = clonedChunk;\n\t\t\tcloned.byEnd[clonedChunk.end] = clonedChunk;\n\n\t\t\tconst nextOriginalChunk = originalChunk.next;\n\t\t\tconst nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();\n\n\t\t\tif (nextClonedChunk) {\n\t\t\t\tclonedChunk.next = nextClonedChunk;\n\t\t\t\tnextClonedChunk.previous = clonedChunk;\n\n\t\t\t\tclonedChunk = nextClonedChunk;\n\t\t\t}\n\n\t\t\toriginalChunk = nextOriginalChunk;\n\t\t}\n\n\t\tcloned.lastChunk = clonedChunk;\n\n\t\tif (this.indentExclusionRanges) {\n\t\t\tcloned.indentExclusionRanges = this.indentExclusionRanges.slice();\n\t\t}\n\n\t\tcloned.sourcemapLocations = new BitSet(this.sourcemapLocations);\n\n\t\tcloned.intro = this.intro;\n\t\tcloned.outro = this.outro;\n\n\t\treturn cloned;\n\t}\n\n\tgenerateDecodedMap(options) {\n\t\toptions = options || {};\n\n\t\tconst sourceIndex = 0;\n\t\tconst names = Object.keys(this.storedNames);\n\t\tconst mappings = new Mappings(options.hires);\n\n\t\tconst locate = getLocator(this.original);\n\n\t\tif (this.intro) {\n\t\t\tmappings.advance(this.intro);\n\t\t}\n\n\t\tthis.firstChunk.eachNext((chunk) => {\n\t\t\tconst loc = locate(chunk.start);\n\n\t\t\tif (chunk.intro.length) mappings.advance(chunk.intro);\n\n\t\t\tif (chunk.edited) {\n\t\t\t\tmappings.addEdit(\n\t\t\t\t\tsourceIndex,\n\t\t\t\t\tchunk.content,\n\t\t\t\t\tloc,\n\t\t\t\t\tchunk.storeName ? names.indexOf(chunk.original) : -1,\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tmappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);\n\t\t\t}\n\n\t\t\tif (chunk.outro.length) mappings.advance(chunk.outro);\n\t\t});\n\n\t\tif (this.outro) {\n\t\t\tmappings.advance(this.outro);\n\t\t}\n\n\t\treturn {\n\t\t\tfile: options.file ? options.file.split(/[/\\\\]/).pop() : undefined,\n\t\t\tsources: [\n\t\t\t\toptions.source ? getRelativePath(options.file || '', options.source) : options.file || '',\n\t\t\t],\n\t\t\tsourcesContent: options.includeContent ? [this.original] : undefined,\n\t\t\tnames,\n\t\t\tmappings: mappings.raw,\n\t\t\tx_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,\n\t\t};\n\t}\n\n\tgenerateMap(options) {\n\t\treturn new SourceMap(this.generateDecodedMap(options));\n\t}\n\n\t_ensureindentStr() {\n\t\tif (this.indentStr === undefined) {\n\t\t\tthis.indentStr = guessIndent(this.original);\n\t\t}\n\t}\n\n\t_getRawIndentString() {\n\t\tthis._ensureindentStr();\n\t\treturn this.indentStr;\n\t}\n\n\tgetIndentString() {\n\t\tthis._ensureindentStr();\n\t\treturn this.indentStr === null ? '\\t' : this.indentStr;\n\t}\n\n\tindent(indentStr, options) {\n\t\tconst pattern = /^[^\\r\\n]/gm;\n\n\t\tif (isObject(indentStr)) {\n\t\t\toptions = indentStr;\n\t\t\tindentStr = undefined;\n\t\t}\n\n\t\tif (indentStr === undefined) {\n\t\t\tthis._ensureindentStr();\n\t\t\tindentStr = this.indentStr || '\\t';\n\t\t}\n\n\t\tif (indentStr === '') return this; // noop\n\n\t\toptions = options || {};\n\n\t\t// Process exclusion ranges\n\t\tconst isExcluded = {};\n\n\t\tif (options.exclude) {\n\t\t\tconst exclusions =\n\t\t\t\ttypeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;\n\t\t\texclusions.forEach((exclusion) => {\n\t\t\t\tfor (let i = exclusion[0]; i < exclusion[1]; i += 1) {\n\t\t\t\t\tisExcluded[i] = true;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\tlet shouldIndentNextCharacter = options.indentStart !== false;\n\t\tconst replacer = (match) => {\n\t\t\tif (shouldIndentNextCharacter) return `${indentStr}${match}`;\n\t\t\tshouldIndentNextCharacter = true;\n\t\t\treturn match;\n\t\t};\n\n\t\tthis.intro = this.intro.replace(pattern, replacer);\n\n\t\tlet charIndex = 0;\n\t\tlet chunk = this.firstChunk;\n\n\t\twhile (chunk) {\n\t\t\tconst end = chunk.end;\n\n\t\t\tif (chunk.edited) {\n\t\t\t\tif (!isExcluded[charIndex]) {\n\t\t\t\t\tchunk.content = chunk.content.replace(pattern, replacer);\n\n\t\t\t\t\tif (chunk.content.length) {\n\t\t\t\t\t\tshouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\\n';\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcharIndex = chunk.start;\n\n\t\t\t\twhile (charIndex < end) {\n\t\t\t\t\tif (!isExcluded[charIndex]) {\n\t\t\t\t\t\tconst char = this.original[charIndex];\n\n\t\t\t\t\t\tif (char === '\\n') {\n\t\t\t\t\t\t\tshouldIndentNextCharacter = true;\n\t\t\t\t\t\t} else if (char !== '\\r' && shouldIndentNextCharacter) {\n\t\t\t\t\t\t\tshouldIndentNextCharacter = false;\n\n\t\t\t\t\t\t\tif (charIndex === chunk.start) {\n\t\t\t\t\t\t\t\tchunk.prependRight(indentStr);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis._splitChunk(chunk, charIndex);\n\t\t\t\t\t\t\t\tchunk = chunk.next;\n\t\t\t\t\t\t\t\tchunk.prependRight(indentStr);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tcharIndex += 1;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tcharIndex = chunk.end;\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\tthis.outro = this.outro.replace(pattern, replacer);\n\n\t\treturn this;\n\t}\n\n\tinsert() {\n\t\tthrow new Error(\n\t\t\t'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',\n\t\t);\n\t}\n\n\tinsertLeft(index, content) {\n\t\tif (!warned.insertLeft) {\n\t\t\tconsole.warn(\n\t\t\t\t'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',\n\t\t\t);\n\t\t\twarned.insertLeft = true;\n\t\t}\n\n\t\treturn this.appendLeft(index, content);\n\t}\n\n\tinsertRight(index, content) {\n\t\tif (!warned.insertRight) {\n\t\t\tconsole.warn(\n\t\t\t\t'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',\n\t\t\t);\n\t\t\twarned.insertRight = true;\n\t\t}\n\n\t\treturn this.prependRight(index, content);\n\t}\n\n\tmove(start, end, index) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\t\tindex = index + this.offset;\n\n\t\tif (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');\n\n\t\tif (DEBUG) this.stats.time('move');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\t\tthis._split(index);\n\n\t\tconst first = this.byStart[start];\n\t\tconst last = this.byEnd[end];\n\n\t\tconst oldLeft = first.previous;\n\t\tconst oldRight = last.next;\n\n\t\tconst newRight = this.byStart[index];\n\t\tif (!newRight && last === this.lastChunk) return this;\n\t\tconst newLeft = newRight ? newRight.previous : this.lastChunk;\n\n\t\tif (oldLeft) oldLeft.next = oldRight;\n\t\tif (oldRight) oldRight.previous = oldLeft;\n\n\t\tif (newLeft) newLeft.next = first;\n\t\tif (newRight) newRight.previous = last;\n\n\t\tif (!first.previous) this.firstChunk = last.next;\n\t\tif (!last.next) {\n\t\t\tthis.lastChunk = first.previous;\n\t\t\tthis.lastChunk.next = null;\n\t\t}\n\n\t\tfirst.previous = newLeft;\n\t\tlast.next = newRight || null;\n\n\t\tif (!newLeft) this.firstChunk = first;\n\t\tif (!newRight) this.lastChunk = last;\n\n\t\tif (DEBUG) this.stats.timeEnd('move');\n\t\treturn this;\n\t}\n\n\toverwrite(start, end, content, options) {\n\t\toptions = options || {};\n\t\treturn this.update(start, end, content, { ...options, overwrite: !options.contentOnly });\n\t}\n\n\tupdate(start, end, content, options) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('replacement content must be a string');\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tif (end > this.original.length) throw new Error('end is out of bounds');\n\t\tif (start === end)\n\t\t\tthrow new Error(\n\t\t\t\t'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',\n\t\t\t);\n\n\t\tif (DEBUG) this.stats.time('overwrite');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\n\t\tif (options === true) {\n\t\t\tif (!warned.storeName) {\n\t\t\t\tconsole.warn(\n\t\t\t\t\t'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',\n\t\t\t\t);\n\t\t\t\twarned.storeName = true;\n\t\t\t}\n\n\t\t\toptions = { storeName: true };\n\t\t}\n\t\tconst storeName = options !== undefined ? options.storeName : false;\n\t\tconst overwrite = options !== undefined ? options.overwrite : false;\n\n\t\tif (storeName) {\n\t\t\tconst original = this.original.slice(start, end);\n\t\t\tObject.defineProperty(this.storedNames, original, {\n\t\t\t\twritable: true,\n\t\t\t\tvalue: true,\n\t\t\t\tenumerable: true,\n\t\t\t});\n\t\t}\n\n\t\tconst first = this.byStart[start];\n\t\tconst last = this.byEnd[end];\n\n\t\tif (first) {\n\t\t\tlet chunk = first;\n\t\t\twhile (chunk !== last) {\n\t\t\t\tif (chunk.next !== this.byStart[chunk.end]) {\n\t\t\t\t\tthrow new Error('Cannot overwrite across a split point');\n\t\t\t\t}\n\t\t\t\tchunk = chunk.next;\n\t\t\t\tchunk.edit('', false);\n\t\t\t}\n\n\t\t\tfirst.edit(content, storeName, !overwrite);\n\t\t} else {\n\t\t\t// must be inserting at the end\n\t\t\tconst newChunk = new Chunk(start, end, '').edit(content, storeName);\n\n\t\t\t// TODO last chunk in the array may not be the last chunk, if it's moved...\n\t\t\tlast.next = newChunk;\n\t\t\tnewChunk.previous = last;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('overwrite');\n\t\treturn this;\n\t}\n\n\tprepend(content) {\n\t\tif (typeof content !== 'string') throw new TypeError('outro content must be a string');\n\n\t\tthis.intro = content + this.intro;\n\t\treturn this;\n\t}\n\n\tprependLeft(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('insertRight');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byEnd[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.prependLeft(content);\n\t\t} else {\n\t\t\tthis.intro = content + this.intro;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('insertRight');\n\t\treturn this;\n\t}\n\n\tprependRight(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('insertRight');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byStart[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.prependRight(content);\n\t\t} else {\n\t\t\tthis.outro = content + this.outro;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('insertRight');\n\t\treturn this;\n\t}\n\n\tremove(start, end) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tif (start === end) return this;\n\n\t\tif (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');\n\t\tif (start > end) throw new Error('end must be greater than start');\n\n\t\tif (DEBUG) this.stats.time('remove');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\n\t\tlet chunk = this.byStart[start];\n\n\t\twhile (chunk) {\n\t\t\tchunk.intro = '';\n\t\t\tchunk.outro = '';\n\t\t\tchunk.edit('');\n\n\t\t\tchunk = end > chunk.end ? this.byStart[chunk.end] : null;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('remove');\n\t\treturn this;\n\t}\n\n\treset(start, end) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tif (start === end) return this;\n\n\t\tif (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');\n\t\tif (start > end) throw new Error('end must be greater than start');\n\n\t\tif (DEBUG) this.stats.time('reset');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\n\t\tlet chunk = this.byStart[start];\n\n\t\twhile (chunk) {\n\t\t\tchunk.reset();\n\n\t\t\tchunk = end > chunk.end ? this.byStart[chunk.end] : null;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('reset');\n\t\treturn this;\n\t}\n\n\tlastChar() {\n\t\tif (this.outro.length) return this.outro[this.outro.length - 1];\n\t\tlet chunk = this.lastChunk;\n\t\tdo {\n\t\t\tif (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];\n\t\t\tif (chunk.content.length) return chunk.content[chunk.content.length - 1];\n\t\t\tif (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];\n\t\t} while ((chunk = chunk.previous));\n\t\tif (this.intro.length) return this.intro[this.intro.length - 1];\n\t\treturn '';\n\t}\n\n\tlastLine() {\n\t\tlet lineIndex = this.outro.lastIndexOf(n);\n\t\tif (lineIndex !== -1) return this.outro.substr(lineIndex + 1);\n\t\tlet lineStr = this.outro;\n\t\tlet chunk = this.lastChunk;\n\t\tdo {\n\t\t\tif (chunk.outro.length > 0) {\n\t\t\t\tlineIndex = chunk.outro.lastIndexOf(n);\n\t\t\t\tif (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;\n\t\t\t\tlineStr = chunk.outro + lineStr;\n\t\t\t}\n\n\t\t\tif (chunk.content.length > 0) {\n\t\t\t\tlineIndex = chunk.content.lastIndexOf(n);\n\t\t\t\tif (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;\n\t\t\t\tlineStr = chunk.content + lineStr;\n\t\t\t}\n\n\t\t\tif (chunk.intro.length > 0) {\n\t\t\t\tlineIndex = chunk.intro.lastIndexOf(n);\n\t\t\t\tif (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;\n\t\t\t\tlineStr = chunk.intro + lineStr;\n\t\t\t}\n\t\t} while ((chunk = chunk.previous));\n\t\tlineIndex = this.intro.lastIndexOf(n);\n\t\tif (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;\n\t\treturn this.intro + lineStr;\n\t}\n\n\tslice(start = 0, end = this.original.length - this.offset) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tlet result = '';\n\n\t\t// find start chunk\n\t\tlet chunk = this.firstChunk;\n\t\twhile (chunk && (chunk.start > start || chunk.end <= start)) {\n\t\t\t// found end chunk before start\n\t\t\tif (chunk.start < end && chunk.end >= end) {\n\t\t\t\treturn result;\n\t\t\t}\n\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\tif (chunk && chunk.edited && chunk.start !== start)\n\t\t\tthrow new Error(`Cannot use replaced character ${start} as slice start anchor.`);\n\n\t\tconst startChunk = chunk;\n\t\twhile (chunk) {\n\t\t\tif (chunk.intro && (startChunk !== chunk || chunk.start === start)) {\n\t\t\t\tresult += chunk.intro;\n\t\t\t}\n\n\t\t\tconst containsEnd = chunk.start < end && chunk.end >= end;\n\t\t\tif (containsEnd && chunk.edited && chunk.end !== end)\n\t\t\t\tthrow new Error(`Cannot use replaced character ${end} as slice end anchor.`);\n\n\t\t\tconst sliceStart = startChunk === chunk ? start - chunk.start : 0;\n\t\t\tconst sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;\n\n\t\t\tresult += chunk.content.slice(sliceStart, sliceEnd);\n\n\t\t\tif (chunk.outro && (!containsEnd || chunk.end === end)) {\n\t\t\t\tresult += chunk.outro;\n\t\t\t}\n\n\t\t\tif (containsEnd) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t// TODO deprecate this? not really very useful\n\tsnip(start, end) {\n\t\tconst clone = this.clone();\n\t\tclone.remove(0, start);\n\t\tclone.remove(end, clone.original.length);\n\n\t\treturn clone;\n\t}\n\n\t_split(index) {\n\t\tif (this.byStart[index] || this.byEnd[index]) return;\n\n\t\tif (DEBUG) this.stats.time('_split');\n\n\t\tlet chunk = this.lastSearchedChunk;\n\t\tlet previousChunk = chunk;\n\t\tconst searchForward = index > chunk.end;\n\n\t\twhile (chunk) {\n\t\t\tif (chunk.contains(index)) return this._splitChunk(chunk, index);\n\n\t\t\tchunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];\n\n\t\t\t// Prevent infinite loop (e.g. via empty chunks, where start === end)\n\t\t\tif (chunk === previousChunk) return;\n\n\t\t\tpreviousChunk = chunk;\n\t\t}\n\t}\n\n\t_splitChunk(chunk, index) {\n\t\tif (chunk.edited && chunk.content.length) {\n\t\t\t// zero-length edited chunks are a special case (overlapping replacements)\n\t\t\tconst loc = getLocator(this.original)(index);\n\t\t\tthrow new Error(\n\t\t\t\t`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – \"${chunk.original}\")`,\n\t\t\t);\n\t\t}\n\n\t\tconst newChunk = chunk.split(index);\n\n\t\tthis.byEnd[index] = chunk;\n\t\tthis.byStart[index] = newChunk;\n\t\tthis.byEnd[newChunk.end] = newChunk;\n\n\t\tif (chunk === this.lastChunk) this.lastChunk = newChunk;\n\n\t\tthis.lastSearchedChunk = chunk;\n\t\tif (DEBUG) this.stats.timeEnd('_split');\n\t\treturn true;\n\t}\n\n\ttoString() {\n\t\tlet str = this.intro;\n\n\t\tlet chunk = this.firstChunk;\n\t\twhile (chunk) {\n\t\t\tstr += chunk.toString();\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\treturn str + this.outro;\n\t}\n\n\tisEmpty() {\n\t\tlet chunk = this.firstChunk;\n\t\tdo {\n\t\t\tif (\n\t\t\t\t(chunk.intro.length && chunk.intro.trim()) ||\n\t\t\t\t(chunk.content.length && chunk.content.trim()) ||\n\t\t\t\t(chunk.outro.length && chunk.outro.trim())\n\t\t\t)\n\t\t\t\treturn false;\n\t\t} while ((chunk = chunk.next));\n\t\treturn true;\n\t}\n\n\tlength() {\n\t\tlet chunk = this.firstChunk;\n\t\tlet length = 0;\n\t\tdo {\n\t\t\tlength += chunk.intro.length + chunk.content.length + chunk.outro.length;\n\t\t} while ((chunk = chunk.next));\n\t\treturn length;\n\t}\n\n\ttrimLines() {\n\t\treturn this.trim('[\\\\r\\\\n]');\n\t}\n\n\ttrim(charType) {\n\t\treturn this.trimStart(charType).trimEnd(charType);\n\t}\n\n\ttrimEndAborted(charType) {\n\t\tconst rx = new RegExp((charType || '\\\\s') + '+$');\n\n\t\tthis.outro = this.outro.replace(rx, '');\n\t\tif (this.outro.length) return true;\n\n\t\tlet chunk = this.lastChunk;\n\n\t\tdo {\n\t\t\tconst end = chunk.end;\n\t\t\tconst aborted = chunk.trimEnd(rx);\n\n\t\t\t// if chunk was trimmed, we have a new lastChunk\n\t\t\tif (chunk.end !== end) {\n\t\t\t\tif (this.lastChunk === chunk) {\n\t\t\t\t\tthis.lastChunk = chunk.next;\n\t\t\t\t}\n\n\t\t\t\tthis.byEnd[chunk.end] = chunk;\n\t\t\t\tthis.byStart[chunk.next.start] = chunk.next;\n\t\t\t\tthis.byEnd[chunk.next.end] = chunk.next;\n\t\t\t}\n\n\t\t\tif (aborted) return true;\n\t\t\tchunk = chunk.previous;\n\t\t} while (chunk);\n\n\t\treturn false;\n\t}\n\n\ttrimEnd(charType) {\n\t\tthis.trimEndAborted(charType);\n\t\treturn this;\n\t}\n\ttrimStartAborted(charType) {\n\t\tconst rx = new RegExp('^' + (charType || '\\\\s') + '+');\n\n\t\tthis.intro = this.intro.replace(rx, '');\n\t\tif (this.intro.length) return true;\n\n\t\tlet chunk = this.firstChunk;\n\n\t\tdo {\n\t\t\tconst end = chunk.end;\n\t\t\tconst aborted = chunk.trimStart(rx);\n\n\t\t\tif (chunk.end !== end) {\n\t\t\t\t// special case...\n\t\t\t\tif (chunk === this.lastChunk) this.lastChunk = chunk.next;\n\n\t\t\t\tthis.byEnd[chunk.end] = chunk;\n\t\t\t\tthis.byStart[chunk.next.start] = chunk.next;\n\t\t\t\tthis.byEnd[chunk.next.end] = chunk.next;\n\t\t\t}\n\n\t\t\tif (aborted) return true;\n\t\t\tchunk = chunk.next;\n\t\t} while (chunk);\n\n\t\treturn false;\n\t}\n\n\ttrimStart(charType) {\n\t\tthis.trimStartAborted(charType);\n\t\treturn this;\n\t}\n\n\thasChanged() {\n\t\treturn this.original !== this.toString();\n\t}\n\n\t_replaceRegexp(searchValue, replacement) {\n\t\tfunction getReplacement(match, str) {\n\t\t\tif (typeof replacement === 'string') {\n\t\t\t\treturn replacement.replace(/\\$(\\$|&|\\d+)/g, (_, i) => {\n\t\t\t\t\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter\n\t\t\t\t\tif (i === '$') return '$';\n\t\t\t\t\tif (i === '&') return match[0];\n\t\t\t\t\tconst num = +i;\n\t\t\t\t\tif (num < match.length) return match[+i];\n\t\t\t\t\treturn `$${i}`;\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\treturn replacement(...match, match.index, str, match.groups);\n\t\t\t}\n\t\t}\n\t\tfunction matchAll(re, str) {\n\t\t\tlet match;\n\t\t\tconst matches = [];\n\t\t\twhile ((match = re.exec(str))) {\n\t\t\t\tmatches.push(match);\n\t\t\t}\n\t\t\treturn matches;\n\t\t}\n\t\tif (searchValue.global) {\n\t\t\tconst matches = matchAll(searchValue, this.original);\n\t\t\tmatches.forEach((match) => {\n\t\t\t\tif (match.index != null) {\n\t\t\t\t\tconst replacement = getReplacement(match, this.original);\n\t\t\t\t\tif (replacement !== match[0]) {\n\t\t\t\t\t\tthis.overwrite(match.index, match.index + match[0].length, replacement);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t} else {\n\t\t\tconst match = this.original.match(searchValue);\n\t\t\tif (match && match.index != null) {\n\t\t\t\tconst replacement = getReplacement(match, this.original);\n\t\t\t\tif (replacement !== match[0]) {\n\t\t\t\t\tthis.overwrite(match.index, match.index + match[0].length, replacement);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t_replaceString(string, replacement) {\n\t\tconst { original } = this;\n\t\tconst index = original.indexOf(string);\n\n\t\tif (index !== -1) {\n\t\t\tif (typeof replacement === 'function') {\n\t\t\t\treplacement = replacement(string, index, original);\n\t\t\t}\n\t\t\tif (string !== replacement) {\n\t\t\t\tthis.overwrite(index, index + string.length, replacement);\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t}\n\n\treplace(searchValue, replacement) {\n\t\tif (typeof searchValue === 'string') {\n\t\t\treturn this._replaceString(searchValue, replacement);\n\t\t}\n\n\t\treturn this._replaceRegexp(searchValue, replacement);\n\t}\n\n\t_replaceAllString(string, replacement) {\n\t\tconst { original } = this;\n\t\tconst stringLength = string.length;\n\t\tfor (\n\t\t\tlet index = original.indexOf(string);\n\t\t\tindex !== -1;\n\t\t\tindex = original.indexOf(string, index + stringLength)\n\t\t) {\n\t\t\tconst previous = original.slice(index, index + stringLength);\n\t\t\tlet _replacement = replacement;\n\t\t\tif (typeof replacement === 'function') {\n\t\t\t\t_replacement = replacement(previous, index, original);\n\t\t\t}\n\t\t\tif (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);\n\t\t}\n\n\t\treturn this;\n\t}\n\n\treplaceAll(searchValue, replacement) {\n\t\tif (typeof searchValue === 'string') {\n\t\t\treturn this._replaceAllString(searchValue, replacement);\n\t\t}\n\n\t\tif (!searchValue.global) {\n\t\t\tthrow new TypeError(\n\t\t\t\t'MagicString.prototype.replaceAll called with a non-global RegExp argument',\n\t\t\t);\n\t\t}\n\n\t\treturn this._replaceRegexp(searchValue, replacement);\n\t}\n}\n","import MagicString from './MagicString.js';\nimport SourceMap from './SourceMap.js';\nimport getRelativePath from './utils/getRelativePath.js';\nimport isObject from './utils/isObject.js';\nimport getLocator from './utils/getLocator.js';\nimport Mappings from './utils/Mappings.js';\n\nconst hasOwnProp = Object.prototype.hasOwnProperty;\n\nexport default class Bundle {\n\tconstructor(options = {}) {\n\t\tthis.intro = options.intro || '';\n\t\tthis.separator = options.separator !== undefined ? options.separator : '\\n';\n\t\tthis.sources = [];\n\t\tthis.uniqueSources = [];\n\t\tthis.uniqueSourceIndexByFilename = {};\n\t}\n\n\taddSource(source) {\n\t\tif (source instanceof MagicString) {\n\t\t\treturn this.addSource({\n\t\t\t\tcontent: source,\n\t\t\t\tfilename: source.filename,\n\t\t\t\tseparator: this.separator,\n\t\t\t});\n\t\t}\n\n\t\tif (!isObject(source) || !source.content) {\n\t\t\tthrow new Error(\n\t\t\t\t'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`',\n\t\t\t);\n\t\t}\n\n\t\t['filename', 'ignoreList', 'indentExclusionRanges', 'separator'].forEach((option) => {\n\t\t\tif (!hasOwnProp.call(source, option)) source[option] = source.content[option];\n\t\t});\n\n\t\tif (source.separator === undefined) {\n\t\t\t// TODO there's a bunch of this sort of thing, needs cleaning up\n\t\t\tsource.separator = this.separator;\n\t\t}\n\n\t\tif (source.filename) {\n\t\t\tif (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {\n\t\t\t\tthis.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;\n\t\t\t\tthis.uniqueSources.push({ filename: source.filename, content: source.content.original });\n\t\t\t} else {\n\t\t\t\tconst uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];\n\t\t\t\tif (source.content.original !== uniqueSource.content) {\n\t\t\t\t\tthrow new Error(`Illegal source: same filename (${source.filename}), different contents`);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tthis.sources.push(source);\n\t\treturn this;\n\t}\n\n\tappend(str, options) {\n\t\tthis.addSource({\n\t\t\tcontent: new MagicString(str),\n\t\t\tseparator: (options && options.separator) || '',\n\t\t});\n\n\t\treturn this;\n\t}\n\n\tclone() {\n\t\tconst bundle = new Bundle({\n\t\t\tintro: this.intro,\n\t\t\tseparator: this.separator,\n\t\t});\n\n\t\tthis.sources.forEach((source) => {\n\t\t\tbundle.addSource({\n\t\t\t\tfilename: source.filename,\n\t\t\t\tcontent: source.content.clone(),\n\t\t\t\tseparator: source.separator,\n\t\t\t});\n\t\t});\n\n\t\treturn bundle;\n\t}\n\n\tgenerateDecodedMap(options = {}) {\n\t\tconst names = [];\n\t\tlet x_google_ignoreList = undefined;\n\t\tthis.sources.forEach((source) => {\n\t\t\tObject.keys(source.content.storedNames).forEach((name) => {\n\t\t\t\tif (!~names.indexOf(name)) names.push(name);\n\t\t\t});\n\t\t});\n\n\t\tconst mappings = new Mappings(options.hires);\n\n\t\tif (this.intro) {\n\t\t\tmappings.advance(this.intro);\n\t\t}\n\n\t\tthis.sources.forEach((source, i) => {\n\t\t\tif (i > 0) {\n\t\t\t\tmappings.advance(this.separator);\n\t\t\t}\n\n\t\t\tconst sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1;\n\t\t\tconst magicString = source.content;\n\t\t\tconst locate = getLocator(magicString.original);\n\n\t\t\tif (magicString.intro) {\n\t\t\t\tmappings.advance(magicString.intro);\n\t\t\t}\n\n\t\t\tmagicString.firstChunk.eachNext((chunk) => {\n\t\t\t\tconst loc = locate(chunk.start);\n\n\t\t\t\tif (chunk.intro.length) mappings.advance(chunk.intro);\n\n\t\t\t\tif (source.filename) {\n\t\t\t\t\tif (chunk.edited) {\n\t\t\t\t\t\tmappings.addEdit(\n\t\t\t\t\t\t\tsourceIndex,\n\t\t\t\t\t\t\tchunk.content,\n\t\t\t\t\t\t\tloc,\n\t\t\t\t\t\t\tchunk.storeName ? names.indexOf(chunk.original) : -1,\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tmappings.addUneditedChunk(\n\t\t\t\t\t\t\tsourceIndex,\n\t\t\t\t\t\t\tchunk,\n\t\t\t\t\t\t\tmagicString.original,\n\t\t\t\t\t\t\tloc,\n\t\t\t\t\t\t\tmagicString.sourcemapLocations,\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tmappings.advance(chunk.content);\n\t\t\t\t}\n\n\t\t\t\tif (chunk.outro.length) mappings.advance(chunk.outro);\n\t\t\t});\n\n\t\t\tif (magicString.outro) {\n\t\t\t\tmappings.advance(magicString.outro);\n\t\t\t}\n\n\t\t\tif (source.ignoreList && sourceIndex !== -1) {\n\t\t\t\tif (x_google_ignoreList === undefined) {\n\t\t\t\t\tx_google_ignoreList = [];\n\t\t\t\t}\n\t\t\t\tx_google_ignoreList.push(sourceIndex);\n\t\t\t}\n\t\t});\n\n\t\treturn {\n\t\t\tfile: options.file ? options.file.split(/[/\\\\]/).pop() : undefined,\n\t\t\tsources: this.uniqueSources.map((source) => {\n\t\t\t\treturn options.file ? getRelativePath(options.file, source.filename) : source.filename;\n\t\t\t}),\n\t\t\tsourcesContent: this.uniqueSources.map((source) => {\n\t\t\t\treturn options.includeContent ? source.content : null;\n\t\t\t}),\n\t\t\tnames,\n\t\t\tmappings: mappings.raw,\n\t\t\tx_google_ignoreList,\n\t\t};\n\t}\n\n\tgenerateMap(options) {\n\t\treturn new SourceMap(this.generateDecodedMap(options));\n\t}\n\n\tgetIndentString() {\n\t\tconst indentStringCounts = {};\n\n\t\tthis.sources.forEach((source) => {\n\t\t\tconst indentStr = source.content._getRawIndentString();\n\n\t\t\tif (indentStr === null) return;\n\n\t\t\tif (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0;\n\t\t\tindentStringCounts[indentStr] += 1;\n\t\t});\n\n\t\treturn (\n\t\t\tObject.keys(indentStringCounts).sort((a, b) => {\n\t\t\t\treturn indentStringCounts[a] - indentStringCounts[b];\n\t\t\t})[0] || '\\t'\n\t\t);\n\t}\n\n\tindent(indentStr) {\n\t\tif (!arguments.length) {\n\t\t\tindentStr = this.getIndentString();\n\t\t}\n\n\t\tif (indentStr === '') return this; // noop\n\n\t\tlet trailingNewline = !this.intro || this.intro.slice(-1) === '\\n';\n\n\t\tthis.sources.forEach((source, i) => {\n\t\t\tconst separator = source.separator !== undefined ? source.separator : this.separator;\n\t\t\tconst indentStart = trailingNewline || (i > 0 && /\\r?\\n$/.test(separator));\n\n\t\t\tsource.content.indent(indentStr, {\n\t\t\t\texclude: source.indentExclusionRanges,\n\t\t\t\tindentStart, //: trailingNewline || /\\r?\\n$/.test( separator ) //true///\\r?\\n/.test( separator )\n\t\t\t});\n\n\t\t\ttrailingNewline = source.content.lastChar() === '\\n';\n\t\t});\n\n\t\tif (this.intro) {\n\t\t\tthis.intro =\n\t\t\t\tindentStr +\n\t\t\t\tthis.intro.replace(/^[^\\n]/gm, (match, index) => {\n\t\t\t\t\treturn index > 0 ? indentStr + match : match;\n\t\t\t\t});\n\t\t}\n\n\t\treturn this;\n\t}\n\n\tprepend(str) {\n\t\tthis.intro = str + this.intro;\n\t\treturn this;\n\t}\n\n\ttoString() {\n\t\tconst body = this.sources\n\t\t\t.map((source, i) => {\n\t\t\t\tconst separator = source.separator !== undefined ? source.separator : this.separator;\n\t\t\t\tconst str = (i > 0 ? separator : '') + source.content.toString();\n\n\t\t\t\treturn str;\n\t\t\t})\n\t\t\t.join('');\n\n\t\treturn this.intro + body;\n\t}\n\n\tisEmpty() {\n\t\tif (this.intro.length && this.intro.trim()) return false;\n\t\tif (this.sources.some((source) => !source.content.isEmpty())) return false;\n\t\treturn true;\n\t}\n\n\tlength() {\n\t\treturn this.sources.reduce(\n\t\t\t(length, source) => length + source.content.length(),\n\t\t\tthis.intro.length,\n\t\t);\n\t}\n\n\ttrimLines() {\n\t\treturn this.trim('[\\\\r\\\\n]');\n\t}\n\n\ttrim(charType) {\n\t\treturn this.trimStart(charType).trimEnd(charType);\n\t}\n\n\ttrimStart(charType) {\n\t\tconst rx = new RegExp('^' + (charType || '\\\\s') + '+');\n\t\tthis.intro = this.intro.replace(rx, '');\n\n\t\tif (!this.intro) {\n\t\t\tlet source;\n\t\t\tlet i = 0;\n\n\t\t\tdo {\n\t\t\t\tsource = this.sources[i++];\n\t\t\t\tif (!source) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t} while (!source.content.trimStartAborted(charType));\n\t\t}\n\n\t\treturn this;\n\t}\n\n\ttrimEnd(charType) {\n\t\tconst rx = new RegExp((charType || '\\\\s') + '+$');\n\n\t\tlet source;\n\t\tlet i = this.sources.length - 1;\n\n\t\tdo {\n\t\t\tsource = this.sources[i--];\n\t\t\tif (!source) {\n\t\t\t\tthis.intro = this.intro.replace(rx, '');\n\t\t\t\tbreak;\n\t\t\t}\n\t\t} while (!source.content.trimEndAborted(charType));\n\n\t\treturn this;\n\t}\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/frontend/node_modules/magic-string/dist/magic-string.umd.js b/frontend/node_modules/magic-string/dist/magic-string.umd.js new file mode 100644 index 0000000..0c399cd --- /dev/null +++ b/frontend/node_modules/magic-string/dist/magic-string.umd.js @@ -0,0 +1,1682 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.MagicString = factory()); +})(this, (function () { 'use strict'; + + class BitSet { + constructor(arg) { + this.bits = arg instanceof BitSet ? arg.bits.slice() : []; + } + + add(n) { + this.bits[n >> 5] |= 1 << (n & 31); + } + + has(n) { + return !!(this.bits[n >> 5] & (1 << (n & 31))); + } + } + + class Chunk { + constructor(start, end, content) { + this.start = start; + this.end = end; + this.original = content; + + this.intro = ''; + this.outro = ''; + + this.content = content; + this.storeName = false; + this.edited = false; + + { + this.previous = null; + this.next = null; + } + } + + appendLeft(content) { + this.outro += content; + } + + appendRight(content) { + this.intro = this.intro + content; + } + + clone() { + const chunk = new Chunk(this.start, this.end, this.original); + + chunk.intro = this.intro; + chunk.outro = this.outro; + chunk.content = this.content; + chunk.storeName = this.storeName; + chunk.edited = this.edited; + + return chunk; + } + + contains(index) { + return this.start < index && index < this.end; + } + + eachNext(fn) { + let chunk = this; + while (chunk) { + fn(chunk); + chunk = chunk.next; + } + } + + eachPrevious(fn) { + let chunk = this; + while (chunk) { + fn(chunk); + chunk = chunk.previous; + } + } + + edit(content, storeName, contentOnly) { + this.content = content; + if (!contentOnly) { + this.intro = ''; + this.outro = ''; + } + this.storeName = storeName; + + this.edited = true; + + return this; + } + + prependLeft(content) { + this.outro = content + this.outro; + } + + prependRight(content) { + this.intro = content + this.intro; + } + + reset() { + this.intro = ''; + this.outro = ''; + if (this.edited) { + this.content = this.original; + this.storeName = false; + this.edited = false; + } + } + + split(index) { + const sliceIndex = index - this.start; + + const originalBefore = this.original.slice(0, sliceIndex); + const originalAfter = this.original.slice(sliceIndex); + + this.original = originalBefore; + + const newChunk = new Chunk(index, this.end, originalAfter); + newChunk.outro = this.outro; + this.outro = ''; + + this.end = index; + + if (this.edited) { + // after split we should save the edit content record into the correct chunk + // to make sure sourcemap correct + // For example: + // ' test'.trim() + // split -> ' ' + 'test' + // ✔️ edit -> '' + 'test' + // ✖️ edit -> 'test' + '' + // TODO is this block necessary?... + newChunk.edit('', false); + this.content = ''; + } else { + this.content = originalBefore; + } + + newChunk.next = this.next; + if (newChunk.next) newChunk.next.previous = newChunk; + newChunk.previous = this; + this.next = newChunk; + + return newChunk; + } + + toString() { + return this.intro + this.content + this.outro; + } + + trimEnd(rx) { + this.outro = this.outro.replace(rx, ''); + if (this.outro.length) return true; + + const trimmed = this.content.replace(rx, ''); + + if (trimmed.length) { + if (trimmed !== this.content) { + this.split(this.start + trimmed.length).edit('', undefined, true); + if (this.edited) { + // save the change, if it has been edited + this.edit(trimmed, this.storeName, true); + } + } + return true; + } else { + this.edit('', undefined, true); + + this.intro = this.intro.replace(rx, ''); + if (this.intro.length) return true; + } + } + + trimStart(rx) { + this.intro = this.intro.replace(rx, ''); + if (this.intro.length) return true; + + const trimmed = this.content.replace(rx, ''); + + if (trimmed.length) { + if (trimmed !== this.content) { + const newChunk = this.split(this.end - trimmed.length); + if (this.edited) { + // save the change, if it has been edited + newChunk.edit(trimmed, this.storeName, true); + } + this.edit('', undefined, true); + } + return true; + } else { + this.edit('', undefined, true); + + this.outro = this.outro.replace(rx, ''); + if (this.outro.length) return true; + } + } + } + + // src/vlq.ts + var comma = ",".charCodeAt(0); + var semicolon = ";".charCodeAt(0); + var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var intToChar = new Uint8Array(64); + var charToInt = new Uint8Array(128); + for (let i = 0; i < chars.length; i++) { + const c = chars.charCodeAt(i); + intToChar[i] = c; + charToInt[c] = i; + } + function encodeInteger(builder, num, relative) { + let delta = num - relative; + delta = delta < 0 ? -delta << 1 | 1 : delta << 1; + do { + let clamped = delta & 31; + delta >>>= 5; + if (delta > 0) clamped |= 32; + builder.write(intToChar[clamped]); + } while (delta > 0); + return num; + } + + // src/strings.ts + var bufLength = 1024 * 16; + var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { + decode(buf) { + const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength); + return out.toString(); + } + } : { + decode(buf) { + let out = ""; + for (let i = 0; i < buf.length; i++) { + out += String.fromCharCode(buf[i]); + } + return out; + } + }; + var StringWriter = class { + constructor() { + this.pos = 0; + this.out = ""; + this.buffer = new Uint8Array(bufLength); + } + write(v) { + const { buffer } = this; + buffer[this.pos++] = v; + if (this.pos === bufLength) { + this.out += td.decode(buffer); + this.pos = 0; + } + } + flush() { + const { buffer, out, pos } = this; + return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out; + } + }; + function encode(decoded) { + const writer = new StringWriter(); + let sourcesIndex = 0; + let sourceLine = 0; + let sourceColumn = 0; + let namesIndex = 0; + for (let i = 0; i < decoded.length; i++) { + const line = decoded[i]; + if (i > 0) writer.write(semicolon); + if (line.length === 0) continue; + let genColumn = 0; + for (let j = 0; j < line.length; j++) { + const segment = line[j]; + if (j > 0) writer.write(comma); + genColumn = encodeInteger(writer, segment[0], genColumn); + if (segment.length === 1) continue; + sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex); + sourceLine = encodeInteger(writer, segment[2], sourceLine); + sourceColumn = encodeInteger(writer, segment[3], sourceColumn); + if (segment.length === 4) continue; + namesIndex = encodeInteger(writer, segment[4], namesIndex); + } + } + return writer.flush(); + } + + function getBtoa() { + if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') { + return (str) => globalThis.btoa(unescape(encodeURIComponent(str))); + } else if (typeof Buffer === 'function') { + return (str) => Buffer.from(str, 'utf-8').toString('base64'); + } else { + return () => { + throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.'); + }; + } + } + + const btoa = /*#__PURE__*/ getBtoa(); + + class SourceMap { + constructor(properties) { + this.version = 3; + this.file = properties.file; + this.sources = properties.sources; + this.sourcesContent = properties.sourcesContent; + this.names = properties.names; + this.mappings = encode(properties.mappings); + if (typeof properties.x_google_ignoreList !== 'undefined') { + this.x_google_ignoreList = properties.x_google_ignoreList; + } + if (typeof properties.debugId !== 'undefined') { + this.debugId = properties.debugId; + } + } + + toString() { + return JSON.stringify(this); + } + + toUrl() { + return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString()); + } + } + + function guessIndent(code) { + const lines = code.split('\n'); + + const tabbed = lines.filter((line) => /^\t+/.test(line)); + const spaced = lines.filter((line) => /^ {2,}/.test(line)); + + if (tabbed.length === 0 && spaced.length === 0) { + return null; + } + + // More lines tabbed than spaced? Assume tabs, and + // default to tabs in the case of a tie (or nothing + // to go on) + if (tabbed.length >= spaced.length) { + return '\t'; + } + + // Otherwise, we need to guess the multiple + const min = spaced.reduce((previous, current) => { + const numSpaces = /^ +/.exec(current)[0].length; + return Math.min(numSpaces, previous); + }, Infinity); + + return new Array(min + 1).join(' '); + } + + function getRelativePath(from, to) { + const fromParts = from.split(/[/\\]/); + const toParts = to.split(/[/\\]/); + + fromParts.pop(); // get dirname + + while (fromParts[0] === toParts[0]) { + fromParts.shift(); + toParts.shift(); + } + + if (fromParts.length) { + let i = fromParts.length; + while (i--) fromParts[i] = '..'; + } + + return fromParts.concat(toParts).join('/'); + } + + const toString = Object.prototype.toString; + + function isObject(thing) { + return toString.call(thing) === '[object Object]'; + } + + function getLocator(source) { + const originalLines = source.split('\n'); + const lineOffsets = []; + + for (let i = 0, pos = 0; i < originalLines.length; i++) { + lineOffsets.push(pos); + pos += originalLines[i].length + 1; + } + + return function locate(index) { + let i = 0; + let j = lineOffsets.length; + while (i < j) { + const m = (i + j) >> 1; + if (index < lineOffsets[m]) { + j = m; + } else { + i = m + 1; + } + } + const line = i - 1; + const column = index - lineOffsets[line]; + return { line, column }; + }; + } + + const wordRegex = /\w/; + + class Mappings { + constructor(hires) { + this.hires = hires; + this.generatedCodeLine = 0; + this.generatedCodeColumn = 0; + this.raw = []; + this.rawSegments = this.raw[this.generatedCodeLine] = []; + this.pending = null; + } + + addEdit(sourceIndex, content, loc, nameIndex) { + if (content.length) { + const contentLengthMinusOne = content.length - 1; + let contentLineEnd = content.indexOf('\n', 0); + let previousContentLineEnd = -1; + // Loop through each line in the content and add a segment, but stop if the last line is empty, + // else code afterwards would fill one line too many + while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) { + const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; + if (nameIndex >= 0) { + segment.push(nameIndex); + } + this.rawSegments.push(segment); + + this.generatedCodeLine += 1; + this.raw[this.generatedCodeLine] = this.rawSegments = []; + this.generatedCodeColumn = 0; + + previousContentLineEnd = contentLineEnd; + contentLineEnd = content.indexOf('\n', contentLineEnd + 1); + } + + const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; + if (nameIndex >= 0) { + segment.push(nameIndex); + } + this.rawSegments.push(segment); + + this.advance(content.slice(previousContentLineEnd + 1)); + } else if (this.pending) { + this.rawSegments.push(this.pending); + this.advance(content); + } + + this.pending = null; + } + + addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) { + let originalCharIndex = chunk.start; + let first = true; + // when iterating each char, check if it's in a word boundary + let charInHiresBoundary = false; + + while (originalCharIndex < chunk.end) { + if (original[originalCharIndex] === '\n') { + loc.line += 1; + loc.column = 0; + this.generatedCodeLine += 1; + this.raw[this.generatedCodeLine] = this.rawSegments = []; + this.generatedCodeColumn = 0; + first = true; + charInHiresBoundary = false; + } else { + if (this.hires || first || sourcemapLocations.has(originalCharIndex)) { + const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; + + if (this.hires === 'boundary') { + // in hires "boundary", group segments per word boundary than per char + if (wordRegex.test(original[originalCharIndex])) { + // for first char in the boundary found, start the boundary by pushing a segment + if (!charInHiresBoundary) { + this.rawSegments.push(segment); + charInHiresBoundary = true; + } + } else { + // for non-word char, end the boundary by pushing a segment + this.rawSegments.push(segment); + charInHiresBoundary = false; + } + } else { + this.rawSegments.push(segment); + } + } + + loc.column += 1; + this.generatedCodeColumn += 1; + first = false; + } + + originalCharIndex += 1; + } + + this.pending = null; + } + + advance(str) { + if (!str) return; + + const lines = str.split('\n'); + + if (lines.length > 1) { + for (let i = 0; i < lines.length - 1; i++) { + this.generatedCodeLine++; + this.raw[this.generatedCodeLine] = this.rawSegments = []; + } + this.generatedCodeColumn = 0; + } + + this.generatedCodeColumn += lines[lines.length - 1].length; + } + } + + const n = '\n'; + + const warned = { + insertLeft: false, + insertRight: false, + storeName: false, + }; + + class MagicString { + constructor(string, options = {}) { + const chunk = new Chunk(0, string.length, string); + + Object.defineProperties(this, { + original: { writable: true, value: string }, + outro: { writable: true, value: '' }, + intro: { writable: true, value: '' }, + firstChunk: { writable: true, value: chunk }, + lastChunk: { writable: true, value: chunk }, + lastSearchedChunk: { writable: true, value: chunk }, + byStart: { writable: true, value: {} }, + byEnd: { writable: true, value: {} }, + filename: { writable: true, value: options.filename }, + indentExclusionRanges: { writable: true, value: options.indentExclusionRanges }, + sourcemapLocations: { writable: true, value: new BitSet() }, + storedNames: { writable: true, value: {} }, + indentStr: { writable: true, value: undefined }, + ignoreList: { writable: true, value: options.ignoreList }, + offset: { writable: true, value: options.offset || 0 }, + }); + + this.byStart[0] = chunk; + this.byEnd[string.length] = chunk; + } + + addSourcemapLocation(char) { + this.sourcemapLocations.add(char); + } + + append(content) { + if (typeof content !== 'string') throw new TypeError('outro content must be a string'); + + this.outro += content; + return this; + } + + appendLeft(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byEnd[index]; + + if (chunk) { + chunk.appendLeft(content); + } else { + this.intro += content; + } + return this; + } + + appendRight(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byStart[index]; + + if (chunk) { + chunk.appendRight(content); + } else { + this.outro += content; + } + return this; + } + + clone() { + const cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset }); + + let originalChunk = this.firstChunk; + let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone()); + + while (originalChunk) { + cloned.byStart[clonedChunk.start] = clonedChunk; + cloned.byEnd[clonedChunk.end] = clonedChunk; + + const nextOriginalChunk = originalChunk.next; + const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone(); + + if (nextClonedChunk) { + clonedChunk.next = nextClonedChunk; + nextClonedChunk.previous = clonedChunk; + + clonedChunk = nextClonedChunk; + } + + originalChunk = nextOriginalChunk; + } + + cloned.lastChunk = clonedChunk; + + if (this.indentExclusionRanges) { + cloned.indentExclusionRanges = this.indentExclusionRanges.slice(); + } + + cloned.sourcemapLocations = new BitSet(this.sourcemapLocations); + + cloned.intro = this.intro; + cloned.outro = this.outro; + + return cloned; + } + + generateDecodedMap(options) { + options = options || {}; + + const sourceIndex = 0; + const names = Object.keys(this.storedNames); + const mappings = new Mappings(options.hires); + + const locate = getLocator(this.original); + + if (this.intro) { + mappings.advance(this.intro); + } + + this.firstChunk.eachNext((chunk) => { + const loc = locate(chunk.start); + + if (chunk.intro.length) mappings.advance(chunk.intro); + + if (chunk.edited) { + mappings.addEdit( + sourceIndex, + chunk.content, + loc, + chunk.storeName ? names.indexOf(chunk.original) : -1, + ); + } else { + mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations); + } + + if (chunk.outro.length) mappings.advance(chunk.outro); + }); + + if (this.outro) { + mappings.advance(this.outro); + } + + return { + file: options.file ? options.file.split(/[/\\]/).pop() : undefined, + sources: [ + options.source ? getRelativePath(options.file || '', options.source) : options.file || '', + ], + sourcesContent: options.includeContent ? [this.original] : undefined, + names, + mappings: mappings.raw, + x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined, + }; + } + + generateMap(options) { + return new SourceMap(this.generateDecodedMap(options)); + } + + _ensureindentStr() { + if (this.indentStr === undefined) { + this.indentStr = guessIndent(this.original); + } + } + + _getRawIndentString() { + this._ensureindentStr(); + return this.indentStr; + } + + getIndentString() { + this._ensureindentStr(); + return this.indentStr === null ? '\t' : this.indentStr; + } + + indent(indentStr, options) { + const pattern = /^[^\r\n]/gm; + + if (isObject(indentStr)) { + options = indentStr; + indentStr = undefined; + } + + if (indentStr === undefined) { + this._ensureindentStr(); + indentStr = this.indentStr || '\t'; + } + + if (indentStr === '') return this; // noop + + options = options || {}; + + // Process exclusion ranges + const isExcluded = {}; + + if (options.exclude) { + const exclusions = + typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude; + exclusions.forEach((exclusion) => { + for (let i = exclusion[0]; i < exclusion[1]; i += 1) { + isExcluded[i] = true; + } + }); + } + + let shouldIndentNextCharacter = options.indentStart !== false; + const replacer = (match) => { + if (shouldIndentNextCharacter) return `${indentStr}${match}`; + shouldIndentNextCharacter = true; + return match; + }; + + this.intro = this.intro.replace(pattern, replacer); + + let charIndex = 0; + let chunk = this.firstChunk; + + while (chunk) { + const end = chunk.end; + + if (chunk.edited) { + if (!isExcluded[charIndex]) { + chunk.content = chunk.content.replace(pattern, replacer); + + if (chunk.content.length) { + shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n'; + } + } + } else { + charIndex = chunk.start; + + while (charIndex < end) { + if (!isExcluded[charIndex]) { + const char = this.original[charIndex]; + + if (char === '\n') { + shouldIndentNextCharacter = true; + } else if (char !== '\r' && shouldIndentNextCharacter) { + shouldIndentNextCharacter = false; + + if (charIndex === chunk.start) { + chunk.prependRight(indentStr); + } else { + this._splitChunk(chunk, charIndex); + chunk = chunk.next; + chunk.prependRight(indentStr); + } + } + } + + charIndex += 1; + } + } + + charIndex = chunk.end; + chunk = chunk.next; + } + + this.outro = this.outro.replace(pattern, replacer); + + return this; + } + + insert() { + throw new Error( + 'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)', + ); + } + + insertLeft(index, content) { + if (!warned.insertLeft) { + console.warn( + 'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead', + ); + warned.insertLeft = true; + } + + return this.appendLeft(index, content); + } + + insertRight(index, content) { + if (!warned.insertRight) { + console.warn( + 'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead', + ); + warned.insertRight = true; + } + + return this.prependRight(index, content); + } + + move(start, end, index) { + start = start + this.offset; + end = end + this.offset; + index = index + this.offset; + + if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself'); + + this._split(start); + this._split(end); + this._split(index); + + const first = this.byStart[start]; + const last = this.byEnd[end]; + + const oldLeft = first.previous; + const oldRight = last.next; + + const newRight = this.byStart[index]; + if (!newRight && last === this.lastChunk) return this; + const newLeft = newRight ? newRight.previous : this.lastChunk; + + if (oldLeft) oldLeft.next = oldRight; + if (oldRight) oldRight.previous = oldLeft; + + if (newLeft) newLeft.next = first; + if (newRight) newRight.previous = last; + + if (!first.previous) this.firstChunk = last.next; + if (!last.next) { + this.lastChunk = first.previous; + this.lastChunk.next = null; + } + + first.previous = newLeft; + last.next = newRight || null; + + if (!newLeft) this.firstChunk = first; + if (!newRight) this.lastChunk = last; + return this; + } + + overwrite(start, end, content, options) { + options = options || {}; + return this.update(start, end, content, { ...options, overwrite: !options.contentOnly }); + } + + update(start, end, content, options) { + start = start + this.offset; + end = end + this.offset; + + if (typeof content !== 'string') throw new TypeError('replacement content must be a string'); + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + if (end > this.original.length) throw new Error('end is out of bounds'); + if (start === end) + throw new Error( + 'Cannot overwrite a zero-length range – use appendLeft or prependRight instead', + ); + + this._split(start); + this._split(end); + + if (options === true) { + if (!warned.storeName) { + console.warn( + 'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string', + ); + warned.storeName = true; + } + + options = { storeName: true }; + } + const storeName = options !== undefined ? options.storeName : false; + const overwrite = options !== undefined ? options.overwrite : false; + + if (storeName) { + const original = this.original.slice(start, end); + Object.defineProperty(this.storedNames, original, { + writable: true, + value: true, + enumerable: true, + }); + } + + const first = this.byStart[start]; + const last = this.byEnd[end]; + + if (first) { + let chunk = first; + while (chunk !== last) { + if (chunk.next !== this.byStart[chunk.end]) { + throw new Error('Cannot overwrite across a split point'); + } + chunk = chunk.next; + chunk.edit('', false); + } + + first.edit(content, storeName, !overwrite); + } else { + // must be inserting at the end + const newChunk = new Chunk(start, end, '').edit(content, storeName); + + // TODO last chunk in the array may not be the last chunk, if it's moved... + last.next = newChunk; + newChunk.previous = last; + } + return this; + } + + prepend(content) { + if (typeof content !== 'string') throw new TypeError('outro content must be a string'); + + this.intro = content + this.intro; + return this; + } + + prependLeft(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byEnd[index]; + + if (chunk) { + chunk.prependLeft(content); + } else { + this.intro = content + this.intro; + } + return this; + } + + prependRight(index, content) { + index = index + this.offset; + + if (typeof content !== 'string') throw new TypeError('inserted content must be a string'); + + this._split(index); + + const chunk = this.byStart[index]; + + if (chunk) { + chunk.prependRight(content); + } else { + this.outro = content + this.outro; + } + return this; + } + + remove(start, end) { + start = start + this.offset; + end = end + this.offset; + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + if (start === end) return this; + + if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds'); + if (start > end) throw new Error('end must be greater than start'); + + this._split(start); + this._split(end); + + let chunk = this.byStart[start]; + + while (chunk) { + chunk.intro = ''; + chunk.outro = ''; + chunk.edit(''); + + chunk = end > chunk.end ? this.byStart[chunk.end] : null; + } + return this; + } + + reset(start, end) { + start = start + this.offset; + end = end + this.offset; + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + if (start === end) return this; + + if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds'); + if (start > end) throw new Error('end must be greater than start'); + + this._split(start); + this._split(end); + + let chunk = this.byStart[start]; + + while (chunk) { + chunk.reset(); + + chunk = end > chunk.end ? this.byStart[chunk.end] : null; + } + return this; + } + + lastChar() { + if (this.outro.length) return this.outro[this.outro.length - 1]; + let chunk = this.lastChunk; + do { + if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1]; + if (chunk.content.length) return chunk.content[chunk.content.length - 1]; + if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1]; + } while ((chunk = chunk.previous)); + if (this.intro.length) return this.intro[this.intro.length - 1]; + return ''; + } + + lastLine() { + let lineIndex = this.outro.lastIndexOf(n); + if (lineIndex !== -1) return this.outro.substr(lineIndex + 1); + let lineStr = this.outro; + let chunk = this.lastChunk; + do { + if (chunk.outro.length > 0) { + lineIndex = chunk.outro.lastIndexOf(n); + if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr; + lineStr = chunk.outro + lineStr; + } + + if (chunk.content.length > 0) { + lineIndex = chunk.content.lastIndexOf(n); + if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr; + lineStr = chunk.content + lineStr; + } + + if (chunk.intro.length > 0) { + lineIndex = chunk.intro.lastIndexOf(n); + if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr; + lineStr = chunk.intro + lineStr; + } + } while ((chunk = chunk.previous)); + lineIndex = this.intro.lastIndexOf(n); + if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr; + return this.intro + lineStr; + } + + slice(start = 0, end = this.original.length - this.offset) { + start = start + this.offset; + end = end + this.offset; + + if (this.original.length !== 0) { + while (start < 0) start += this.original.length; + while (end < 0) end += this.original.length; + } + + let result = ''; + + // find start chunk + let chunk = this.firstChunk; + while (chunk && (chunk.start > start || chunk.end <= start)) { + // found end chunk before start + if (chunk.start < end && chunk.end >= end) { + return result; + } + + chunk = chunk.next; + } + + if (chunk && chunk.edited && chunk.start !== start) + throw new Error(`Cannot use replaced character ${start} as slice start anchor.`); + + const startChunk = chunk; + while (chunk) { + if (chunk.intro && (startChunk !== chunk || chunk.start === start)) { + result += chunk.intro; + } + + const containsEnd = chunk.start < end && chunk.end >= end; + if (containsEnd && chunk.edited && chunk.end !== end) + throw new Error(`Cannot use replaced character ${end} as slice end anchor.`); + + const sliceStart = startChunk === chunk ? start - chunk.start : 0; + const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length; + + result += chunk.content.slice(sliceStart, sliceEnd); + + if (chunk.outro && (!containsEnd || chunk.end === end)) { + result += chunk.outro; + } + + if (containsEnd) { + break; + } + + chunk = chunk.next; + } + + return result; + } + + // TODO deprecate this? not really very useful + snip(start, end) { + const clone = this.clone(); + clone.remove(0, start); + clone.remove(end, clone.original.length); + + return clone; + } + + _split(index) { + if (this.byStart[index] || this.byEnd[index]) return; + + let chunk = this.lastSearchedChunk; + let previousChunk = chunk; + const searchForward = index > chunk.end; + + while (chunk) { + if (chunk.contains(index)) return this._splitChunk(chunk, index); + + chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start]; + + // Prevent infinite loop (e.g. via empty chunks, where start === end) + if (chunk === previousChunk) return; + + previousChunk = chunk; + } + } + + _splitChunk(chunk, index) { + if (chunk.edited && chunk.content.length) { + // zero-length edited chunks are a special case (overlapping replacements) + const loc = getLocator(this.original)(index); + throw new Error( + `Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`, + ); + } + + const newChunk = chunk.split(index); + + this.byEnd[index] = chunk; + this.byStart[index] = newChunk; + this.byEnd[newChunk.end] = newChunk; + + if (chunk === this.lastChunk) this.lastChunk = newChunk; + + this.lastSearchedChunk = chunk; + return true; + } + + toString() { + let str = this.intro; + + let chunk = this.firstChunk; + while (chunk) { + str += chunk.toString(); + chunk = chunk.next; + } + + return str + this.outro; + } + + isEmpty() { + let chunk = this.firstChunk; + do { + if ( + (chunk.intro.length && chunk.intro.trim()) || + (chunk.content.length && chunk.content.trim()) || + (chunk.outro.length && chunk.outro.trim()) + ) + return false; + } while ((chunk = chunk.next)); + return true; + } + + length() { + let chunk = this.firstChunk; + let length = 0; + do { + length += chunk.intro.length + chunk.content.length + chunk.outro.length; + } while ((chunk = chunk.next)); + return length; + } + + trimLines() { + return this.trim('[\\r\\n]'); + } + + trim(charType) { + return this.trimStart(charType).trimEnd(charType); + } + + trimEndAborted(charType) { + const rx = new RegExp((charType || '\\s') + '+$'); + + this.outro = this.outro.replace(rx, ''); + if (this.outro.length) return true; + + let chunk = this.lastChunk; + + do { + const end = chunk.end; + const aborted = chunk.trimEnd(rx); + + // if chunk was trimmed, we have a new lastChunk + if (chunk.end !== end) { + if (this.lastChunk === chunk) { + this.lastChunk = chunk.next; + } + + this.byEnd[chunk.end] = chunk; + this.byStart[chunk.next.start] = chunk.next; + this.byEnd[chunk.next.end] = chunk.next; + } + + if (aborted) return true; + chunk = chunk.previous; + } while (chunk); + + return false; + } + + trimEnd(charType) { + this.trimEndAborted(charType); + return this; + } + trimStartAborted(charType) { + const rx = new RegExp('^' + (charType || '\\s') + '+'); + + this.intro = this.intro.replace(rx, ''); + if (this.intro.length) return true; + + let chunk = this.firstChunk; + + do { + const end = chunk.end; + const aborted = chunk.trimStart(rx); + + if (chunk.end !== end) { + // special case... + if (chunk === this.lastChunk) this.lastChunk = chunk.next; + + this.byEnd[chunk.end] = chunk; + this.byStart[chunk.next.start] = chunk.next; + this.byEnd[chunk.next.end] = chunk.next; + } + + if (aborted) return true; + chunk = chunk.next; + } while (chunk); + + return false; + } + + trimStart(charType) { + this.trimStartAborted(charType); + return this; + } + + hasChanged() { + return this.original !== this.toString(); + } + + _replaceRegexp(searchValue, replacement) { + function getReplacement(match, str) { + if (typeof replacement === 'string') { + return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => { + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter + if (i === '$') return '$'; + if (i === '&') return match[0]; + const num = +i; + if (num < match.length) return match[+i]; + return `$${i}`; + }); + } else { + return replacement(...match, match.index, str, match.groups); + } + } + function matchAll(re, str) { + let match; + const matches = []; + while ((match = re.exec(str))) { + matches.push(match); + } + return matches; + } + if (searchValue.global) { + const matches = matchAll(searchValue, this.original); + matches.forEach((match) => { + if (match.index != null) { + const replacement = getReplacement(match, this.original); + if (replacement !== match[0]) { + this.overwrite(match.index, match.index + match[0].length, replacement); + } + } + }); + } else { + const match = this.original.match(searchValue); + if (match && match.index != null) { + const replacement = getReplacement(match, this.original); + if (replacement !== match[0]) { + this.overwrite(match.index, match.index + match[0].length, replacement); + } + } + } + return this; + } + + _replaceString(string, replacement) { + const { original } = this; + const index = original.indexOf(string); + + if (index !== -1) { + if (typeof replacement === 'function') { + replacement = replacement(string, index, original); + } + if (string !== replacement) { + this.overwrite(index, index + string.length, replacement); + } + } + + return this; + } + + replace(searchValue, replacement) { + if (typeof searchValue === 'string') { + return this._replaceString(searchValue, replacement); + } + + return this._replaceRegexp(searchValue, replacement); + } + + _replaceAllString(string, replacement) { + const { original } = this; + const stringLength = string.length; + for ( + let index = original.indexOf(string); + index !== -1; + index = original.indexOf(string, index + stringLength) + ) { + const previous = original.slice(index, index + stringLength); + let _replacement = replacement; + if (typeof replacement === 'function') { + _replacement = replacement(previous, index, original); + } + if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement); + } + + return this; + } + + replaceAll(searchValue, replacement) { + if (typeof searchValue === 'string') { + return this._replaceAllString(searchValue, replacement); + } + + if (!searchValue.global) { + throw new TypeError( + 'MagicString.prototype.replaceAll called with a non-global RegExp argument', + ); + } + + return this._replaceRegexp(searchValue, replacement); + } + } + + const hasOwnProp = Object.prototype.hasOwnProperty; + + class Bundle { + constructor(options = {}) { + this.intro = options.intro || ''; + this.separator = options.separator !== undefined ? options.separator : '\n'; + this.sources = []; + this.uniqueSources = []; + this.uniqueSourceIndexByFilename = {}; + } + + addSource(source) { + if (source instanceof MagicString) { + return this.addSource({ + content: source, + filename: source.filename, + separator: this.separator, + }); + } + + if (!isObject(source) || !source.content) { + throw new Error( + 'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`', + ); + } + + ['filename', 'ignoreList', 'indentExclusionRanges', 'separator'].forEach((option) => { + if (!hasOwnProp.call(source, option)) source[option] = source.content[option]; + }); + + if (source.separator === undefined) { + // TODO there's a bunch of this sort of thing, needs cleaning up + source.separator = this.separator; + } + + if (source.filename) { + if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) { + this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length; + this.uniqueSources.push({ filename: source.filename, content: source.content.original }); + } else { + const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]]; + if (source.content.original !== uniqueSource.content) { + throw new Error(`Illegal source: same filename (${source.filename}), different contents`); + } + } + } + + this.sources.push(source); + return this; + } + + append(str, options) { + this.addSource({ + content: new MagicString(str), + separator: (options && options.separator) || '', + }); + + return this; + } + + clone() { + const bundle = new Bundle({ + intro: this.intro, + separator: this.separator, + }); + + this.sources.forEach((source) => { + bundle.addSource({ + filename: source.filename, + content: source.content.clone(), + separator: source.separator, + }); + }); + + return bundle; + } + + generateDecodedMap(options = {}) { + const names = []; + let x_google_ignoreList = undefined; + this.sources.forEach((source) => { + Object.keys(source.content.storedNames).forEach((name) => { + if (!~names.indexOf(name)) names.push(name); + }); + }); + + const mappings = new Mappings(options.hires); + + if (this.intro) { + mappings.advance(this.intro); + } + + this.sources.forEach((source, i) => { + if (i > 0) { + mappings.advance(this.separator); + } + + const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1; + const magicString = source.content; + const locate = getLocator(magicString.original); + + if (magicString.intro) { + mappings.advance(magicString.intro); + } + + magicString.firstChunk.eachNext((chunk) => { + const loc = locate(chunk.start); + + if (chunk.intro.length) mappings.advance(chunk.intro); + + if (source.filename) { + if (chunk.edited) { + mappings.addEdit( + sourceIndex, + chunk.content, + loc, + chunk.storeName ? names.indexOf(chunk.original) : -1, + ); + } else { + mappings.addUneditedChunk( + sourceIndex, + chunk, + magicString.original, + loc, + magicString.sourcemapLocations, + ); + } + } else { + mappings.advance(chunk.content); + } + + if (chunk.outro.length) mappings.advance(chunk.outro); + }); + + if (magicString.outro) { + mappings.advance(magicString.outro); + } + + if (source.ignoreList && sourceIndex !== -1) { + if (x_google_ignoreList === undefined) { + x_google_ignoreList = []; + } + x_google_ignoreList.push(sourceIndex); + } + }); + + return { + file: options.file ? options.file.split(/[/\\]/).pop() : undefined, + sources: this.uniqueSources.map((source) => { + return options.file ? getRelativePath(options.file, source.filename) : source.filename; + }), + sourcesContent: this.uniqueSources.map((source) => { + return options.includeContent ? source.content : null; + }), + names, + mappings: mappings.raw, + x_google_ignoreList, + }; + } + + generateMap(options) { + return new SourceMap(this.generateDecodedMap(options)); + } + + getIndentString() { + const indentStringCounts = {}; + + this.sources.forEach((source) => { + const indentStr = source.content._getRawIndentString(); + + if (indentStr === null) return; + + if (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0; + indentStringCounts[indentStr] += 1; + }); + + return ( + Object.keys(indentStringCounts).sort((a, b) => { + return indentStringCounts[a] - indentStringCounts[b]; + })[0] || '\t' + ); + } + + indent(indentStr) { + if (!arguments.length) { + indentStr = this.getIndentString(); + } + + if (indentStr === '') return this; // noop + + let trailingNewline = !this.intro || this.intro.slice(-1) === '\n'; + + this.sources.forEach((source, i) => { + const separator = source.separator !== undefined ? source.separator : this.separator; + const indentStart = trailingNewline || (i > 0 && /\r?\n$/.test(separator)); + + source.content.indent(indentStr, { + exclude: source.indentExclusionRanges, + indentStart, //: trailingNewline || /\r?\n$/.test( separator ) //true///\r?\n/.test( separator ) + }); + + trailingNewline = source.content.lastChar() === '\n'; + }); + + if (this.intro) { + this.intro = + indentStr + + this.intro.replace(/^[^\n]/gm, (match, index) => { + return index > 0 ? indentStr + match : match; + }); + } + + return this; + } + + prepend(str) { + this.intro = str + this.intro; + return this; + } + + toString() { + const body = this.sources + .map((source, i) => { + const separator = source.separator !== undefined ? source.separator : this.separator; + const str = (i > 0 ? separator : '') + source.content.toString(); + + return str; + }) + .join(''); + + return this.intro + body; + } + + isEmpty() { + if (this.intro.length && this.intro.trim()) return false; + if (this.sources.some((source) => !source.content.isEmpty())) return false; + return true; + } + + length() { + return this.sources.reduce( + (length, source) => length + source.content.length(), + this.intro.length, + ); + } + + trimLines() { + return this.trim('[\\r\\n]'); + } + + trim(charType) { + return this.trimStart(charType).trimEnd(charType); + } + + trimStart(charType) { + const rx = new RegExp('^' + (charType || '\\s') + '+'); + this.intro = this.intro.replace(rx, ''); + + if (!this.intro) { + let source; + let i = 0; + + do { + source = this.sources[i++]; + if (!source) { + break; + } + } while (!source.content.trimStartAborted(charType)); + } + + return this; + } + + trimEnd(charType) { + const rx = new RegExp((charType || '\\s') + '+$'); + + let source; + let i = this.sources.length - 1; + + do { + source = this.sources[i--]; + if (!source) { + this.intro = this.intro.replace(rx, ''); + break; + } + } while (!source.content.trimEndAborted(charType)); + + return this; + } + } + + MagicString.Bundle = Bundle; + MagicString.SourceMap = SourceMap; + MagicString.default = MagicString; // work around TypeScript bug https://github.com/Rich-Harris/magic-string/pull/121 + + return MagicString; + +})); +//# sourceMappingURL=magic-string.umd.js.map diff --git a/frontend/node_modules/magic-string/dist/magic-string.umd.js.map b/frontend/node_modules/magic-string/dist/magic-string.umd.js.map new file mode 100644 index 0000000..43addb8 --- /dev/null +++ b/frontend/node_modules/magic-string/dist/magic-string.umd.js.map @@ -0,0 +1 @@ +{"version":3,"file":"magic-string.umd.js","sources":["../src/BitSet.js","../src/Chunk.js","../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs","../src/SourceMap.js","../src/utils/guessIndent.js","../src/utils/getRelativePath.js","../src/utils/isObject.js","../src/utils/getLocator.js","../src/utils/Mappings.js","../src/MagicString.js","../src/Bundle.js","../src/index-legacy.js"],"sourcesContent":["export default class BitSet {\n\tconstructor(arg) {\n\t\tthis.bits = arg instanceof BitSet ? arg.bits.slice() : [];\n\t}\n\n\tadd(n) {\n\t\tthis.bits[n >> 5] |= 1 << (n & 31);\n\t}\n\n\thas(n) {\n\t\treturn !!(this.bits[n >> 5] & (1 << (n & 31)));\n\t}\n}\n","export default class Chunk {\n\tconstructor(start, end, content) {\n\t\tthis.start = start;\n\t\tthis.end = end;\n\t\tthis.original = content;\n\n\t\tthis.intro = '';\n\t\tthis.outro = '';\n\n\t\tthis.content = content;\n\t\tthis.storeName = false;\n\t\tthis.edited = false;\n\n\t\tif (DEBUG) {\n\t\t\t// we make these non-enumerable, for sanity while debugging\n\t\t\tObject.defineProperties(this, {\n\t\t\t\tprevious: { writable: true, value: null },\n\t\t\t\tnext: { writable: true, value: null },\n\t\t\t});\n\t\t} else {\n\t\t\tthis.previous = null;\n\t\t\tthis.next = null;\n\t\t}\n\t}\n\n\tappendLeft(content) {\n\t\tthis.outro += content;\n\t}\n\n\tappendRight(content) {\n\t\tthis.intro = this.intro + content;\n\t}\n\n\tclone() {\n\t\tconst chunk = new Chunk(this.start, this.end, this.original);\n\n\t\tchunk.intro = this.intro;\n\t\tchunk.outro = this.outro;\n\t\tchunk.content = this.content;\n\t\tchunk.storeName = this.storeName;\n\t\tchunk.edited = this.edited;\n\n\t\treturn chunk;\n\t}\n\n\tcontains(index) {\n\t\treturn this.start < index && index < this.end;\n\t}\n\n\teachNext(fn) {\n\t\tlet chunk = this;\n\t\twhile (chunk) {\n\t\t\tfn(chunk);\n\t\t\tchunk = chunk.next;\n\t\t}\n\t}\n\n\teachPrevious(fn) {\n\t\tlet chunk = this;\n\t\twhile (chunk) {\n\t\t\tfn(chunk);\n\t\t\tchunk = chunk.previous;\n\t\t}\n\t}\n\n\tedit(content, storeName, contentOnly) {\n\t\tthis.content = content;\n\t\tif (!contentOnly) {\n\t\t\tthis.intro = '';\n\t\t\tthis.outro = '';\n\t\t}\n\t\tthis.storeName = storeName;\n\n\t\tthis.edited = true;\n\n\t\treturn this;\n\t}\n\n\tprependLeft(content) {\n\t\tthis.outro = content + this.outro;\n\t}\n\n\tprependRight(content) {\n\t\tthis.intro = content + this.intro;\n\t}\n\n\treset() {\n\t\tthis.intro = '';\n\t\tthis.outro = '';\n\t\tif (this.edited) {\n\t\t\tthis.content = this.original;\n\t\t\tthis.storeName = false;\n\t\t\tthis.edited = false;\n\t\t}\n\t}\n\n\tsplit(index) {\n\t\tconst sliceIndex = index - this.start;\n\n\t\tconst originalBefore = this.original.slice(0, sliceIndex);\n\t\tconst originalAfter = this.original.slice(sliceIndex);\n\n\t\tthis.original = originalBefore;\n\n\t\tconst newChunk = new Chunk(index, this.end, originalAfter);\n\t\tnewChunk.outro = this.outro;\n\t\tthis.outro = '';\n\n\t\tthis.end = index;\n\n\t\tif (this.edited) {\n\t\t\t// after split we should save the edit content record into the correct chunk\n\t\t\t// to make sure sourcemap correct\n\t\t\t// For example:\n\t\t\t// ' test'.trim()\n\t\t\t// split -> ' ' + 'test'\n\t\t\t// ✔️ edit -> '' + 'test'\n\t\t\t// ✖️ edit -> 'test' + ''\n\t\t\t// TODO is this block necessary?...\n\t\t\tnewChunk.edit('', false);\n\t\t\tthis.content = '';\n\t\t} else {\n\t\t\tthis.content = originalBefore;\n\t\t}\n\n\t\tnewChunk.next = this.next;\n\t\tif (newChunk.next) newChunk.next.previous = newChunk;\n\t\tnewChunk.previous = this;\n\t\tthis.next = newChunk;\n\n\t\treturn newChunk;\n\t}\n\n\ttoString() {\n\t\treturn this.intro + this.content + this.outro;\n\t}\n\n\ttrimEnd(rx) {\n\t\tthis.outro = this.outro.replace(rx, '');\n\t\tif (this.outro.length) return true;\n\n\t\tconst trimmed = this.content.replace(rx, '');\n\n\t\tif (trimmed.length) {\n\t\t\tif (trimmed !== this.content) {\n\t\t\t\tthis.split(this.start + trimmed.length).edit('', undefined, true);\n\t\t\t\tif (this.edited) {\n\t\t\t\t\t// save the change, if it has been edited\n\t\t\t\t\tthis.edit(trimmed, this.storeName, true);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} else {\n\t\t\tthis.edit('', undefined, true);\n\n\t\t\tthis.intro = this.intro.replace(rx, '');\n\t\t\tif (this.intro.length) return true;\n\t\t}\n\t}\n\n\ttrimStart(rx) {\n\t\tthis.intro = this.intro.replace(rx, '');\n\t\tif (this.intro.length) return true;\n\n\t\tconst trimmed = this.content.replace(rx, '');\n\n\t\tif (trimmed.length) {\n\t\t\tif (trimmed !== this.content) {\n\t\t\t\tconst newChunk = this.split(this.end - trimmed.length);\n\t\t\t\tif (this.edited) {\n\t\t\t\t\t// save the change, if it has been edited\n\t\t\t\t\tnewChunk.edit(trimmed, this.storeName, true);\n\t\t\t\t}\n\t\t\t\tthis.edit('', undefined, true);\n\t\t\t}\n\t\t\treturn true;\n\t\t} else {\n\t\t\tthis.edit('', undefined, true);\n\n\t\t\tthis.outro = this.outro.replace(rx, '');\n\t\t\tif (this.outro.length) return true;\n\t\t}\n\t}\n}\n","// src/vlq.ts\nvar comma = \",\".charCodeAt(0);\nvar semicolon = \";\".charCodeAt(0);\nvar chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\nvar intToChar = new Uint8Array(64);\nvar charToInt = new Uint8Array(128);\nfor (let i = 0; i < chars.length; i++) {\n const c = chars.charCodeAt(i);\n intToChar[i] = c;\n charToInt[c] = i;\n}\nfunction decodeInteger(reader, relative) {\n let value = 0;\n let shift = 0;\n let integer = 0;\n do {\n const c = reader.next();\n integer = charToInt[c];\n value |= (integer & 31) << shift;\n shift += 5;\n } while (integer & 32);\n const shouldNegate = value & 1;\n value >>>= 1;\n if (shouldNegate) {\n value = -2147483648 | -value;\n }\n return relative + value;\n}\nfunction encodeInteger(builder, num, relative) {\n let delta = num - relative;\n delta = delta < 0 ? -delta << 1 | 1 : delta << 1;\n do {\n let clamped = delta & 31;\n delta >>>= 5;\n if (delta > 0) clamped |= 32;\n builder.write(intToChar[clamped]);\n } while (delta > 0);\n return num;\n}\nfunction hasMoreVlq(reader, max) {\n if (reader.pos >= max) return false;\n return reader.peek() !== comma;\n}\n\n// src/strings.ts\nvar bufLength = 1024 * 16;\nvar td = typeof TextDecoder !== \"undefined\" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== \"undefined\" ? {\n decode(buf) {\n const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);\n return out.toString();\n }\n} : {\n decode(buf) {\n let out = \"\";\n for (let i = 0; i < buf.length; i++) {\n out += String.fromCharCode(buf[i]);\n }\n return out;\n }\n};\nvar StringWriter = class {\n constructor() {\n this.pos = 0;\n this.out = \"\";\n this.buffer = new Uint8Array(bufLength);\n }\n write(v) {\n const { buffer } = this;\n buffer[this.pos++] = v;\n if (this.pos === bufLength) {\n this.out += td.decode(buffer);\n this.pos = 0;\n }\n }\n flush() {\n const { buffer, out, pos } = this;\n return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;\n }\n};\nvar StringReader = class {\n constructor(buffer) {\n this.pos = 0;\n this.buffer = buffer;\n }\n next() {\n return this.buffer.charCodeAt(this.pos++);\n }\n peek() {\n return this.buffer.charCodeAt(this.pos);\n }\n indexOf(char) {\n const { buffer, pos } = this;\n const idx = buffer.indexOf(char, pos);\n return idx === -1 ? buffer.length : idx;\n }\n};\n\n// src/scopes.ts\nvar EMPTY = [];\nfunction decodeOriginalScopes(input) {\n const { length } = input;\n const reader = new StringReader(input);\n const scopes = [];\n const stack = [];\n let line = 0;\n for (; reader.pos < length; reader.pos++) {\n line = decodeInteger(reader, line);\n const column = decodeInteger(reader, 0);\n if (!hasMoreVlq(reader, length)) {\n const last = stack.pop();\n last[2] = line;\n last[3] = column;\n continue;\n }\n const kind = decodeInteger(reader, 0);\n const fields = decodeInteger(reader, 0);\n const hasName = fields & 1;\n const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind];\n let vars = EMPTY;\n if (hasMoreVlq(reader, length)) {\n vars = [];\n do {\n const varsIndex = decodeInteger(reader, 0);\n vars.push(varsIndex);\n } while (hasMoreVlq(reader, length));\n }\n scope.vars = vars;\n scopes.push(scope);\n stack.push(scope);\n }\n return scopes;\n}\nfunction encodeOriginalScopes(scopes) {\n const writer = new StringWriter();\n for (let i = 0; i < scopes.length; ) {\n i = _encodeOriginalScopes(scopes, i, writer, [0]);\n }\n return writer.flush();\n}\nfunction _encodeOriginalScopes(scopes, index, writer, state) {\n const scope = scopes[index];\n const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;\n if (index > 0) writer.write(comma);\n state[0] = encodeInteger(writer, startLine, state[0]);\n encodeInteger(writer, startColumn, 0);\n encodeInteger(writer, kind, 0);\n const fields = scope.length === 6 ? 1 : 0;\n encodeInteger(writer, fields, 0);\n if (scope.length === 6) encodeInteger(writer, scope[5], 0);\n for (const v of vars) {\n encodeInteger(writer, v, 0);\n }\n for (index++; index < scopes.length; ) {\n const next = scopes[index];\n const { 0: l, 1: c } = next;\n if (l > endLine || l === endLine && c >= endColumn) {\n break;\n }\n index = _encodeOriginalScopes(scopes, index, writer, state);\n }\n writer.write(comma);\n state[0] = encodeInteger(writer, endLine, state[0]);\n encodeInteger(writer, endColumn, 0);\n return index;\n}\nfunction decodeGeneratedRanges(input) {\n const { length } = input;\n const reader = new StringReader(input);\n const ranges = [];\n const stack = [];\n let genLine = 0;\n let definitionSourcesIndex = 0;\n let definitionScopeIndex = 0;\n let callsiteSourcesIndex = 0;\n let callsiteLine = 0;\n let callsiteColumn = 0;\n let bindingLine = 0;\n let bindingColumn = 0;\n do {\n const semi = reader.indexOf(\";\");\n let genColumn = 0;\n for (; reader.pos < semi; reader.pos++) {\n genColumn = decodeInteger(reader, genColumn);\n if (!hasMoreVlq(reader, semi)) {\n const last = stack.pop();\n last[2] = genLine;\n last[3] = genColumn;\n continue;\n }\n const fields = decodeInteger(reader, 0);\n const hasDefinition = fields & 1;\n const hasCallsite = fields & 2;\n const hasScope = fields & 4;\n let callsite = null;\n let bindings = EMPTY;\n let range;\n if (hasDefinition) {\n const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);\n definitionScopeIndex = decodeInteger(\n reader,\n definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0\n );\n definitionSourcesIndex = defSourcesIndex;\n range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];\n } else {\n range = [genLine, genColumn, 0, 0];\n }\n range.isScope = !!hasScope;\n if (hasCallsite) {\n const prevCsi = callsiteSourcesIndex;\n const prevLine = callsiteLine;\n callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);\n const sameSource = prevCsi === callsiteSourcesIndex;\n callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);\n callsiteColumn = decodeInteger(\n reader,\n sameSource && prevLine === callsiteLine ? callsiteColumn : 0\n );\n callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];\n }\n range.callsite = callsite;\n if (hasMoreVlq(reader, semi)) {\n bindings = [];\n do {\n bindingLine = genLine;\n bindingColumn = genColumn;\n const expressionsCount = decodeInteger(reader, 0);\n let expressionRanges;\n if (expressionsCount < -1) {\n expressionRanges = [[decodeInteger(reader, 0)]];\n for (let i = -1; i > expressionsCount; i--) {\n const prevBl = bindingLine;\n bindingLine = decodeInteger(reader, bindingLine);\n bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);\n const expression = decodeInteger(reader, 0);\n expressionRanges.push([expression, bindingLine, bindingColumn]);\n }\n } else {\n expressionRanges = [[expressionsCount]];\n }\n bindings.push(expressionRanges);\n } while (hasMoreVlq(reader, semi));\n }\n range.bindings = bindings;\n ranges.push(range);\n stack.push(range);\n }\n genLine++;\n reader.pos = semi + 1;\n } while (reader.pos < length);\n return ranges;\n}\nfunction encodeGeneratedRanges(ranges) {\n if (ranges.length === 0) return \"\";\n const writer = new StringWriter();\n for (let i = 0; i < ranges.length; ) {\n i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);\n }\n return writer.flush();\n}\nfunction _encodeGeneratedRanges(ranges, index, writer, state) {\n const range = ranges[index];\n const {\n 0: startLine,\n 1: startColumn,\n 2: endLine,\n 3: endColumn,\n isScope,\n callsite,\n bindings\n } = range;\n if (state[0] < startLine) {\n catchupLine(writer, state[0], startLine);\n state[0] = startLine;\n state[1] = 0;\n } else if (index > 0) {\n writer.write(comma);\n }\n state[1] = encodeInteger(writer, range[1], state[1]);\n const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);\n encodeInteger(writer, fields, 0);\n if (range.length === 6) {\n const { 4: sourcesIndex, 5: scopesIndex } = range;\n if (sourcesIndex !== state[2]) {\n state[3] = 0;\n }\n state[2] = encodeInteger(writer, sourcesIndex, state[2]);\n state[3] = encodeInteger(writer, scopesIndex, state[3]);\n }\n if (callsite) {\n const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;\n if (sourcesIndex !== state[4]) {\n state[5] = 0;\n state[6] = 0;\n } else if (callLine !== state[5]) {\n state[6] = 0;\n }\n state[4] = encodeInteger(writer, sourcesIndex, state[4]);\n state[5] = encodeInteger(writer, callLine, state[5]);\n state[6] = encodeInteger(writer, callColumn, state[6]);\n }\n if (bindings) {\n for (const binding of bindings) {\n if (binding.length > 1) encodeInteger(writer, -binding.length, 0);\n const expression = binding[0][0];\n encodeInteger(writer, expression, 0);\n let bindingStartLine = startLine;\n let bindingStartColumn = startColumn;\n for (let i = 1; i < binding.length; i++) {\n const expRange = binding[i];\n bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);\n bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);\n encodeInteger(writer, expRange[0], 0);\n }\n }\n }\n for (index++; index < ranges.length; ) {\n const next = ranges[index];\n const { 0: l, 1: c } = next;\n if (l > endLine || l === endLine && c >= endColumn) {\n break;\n }\n index = _encodeGeneratedRanges(ranges, index, writer, state);\n }\n if (state[0] < endLine) {\n catchupLine(writer, state[0], endLine);\n state[0] = endLine;\n state[1] = 0;\n } else {\n writer.write(comma);\n }\n state[1] = encodeInteger(writer, endColumn, state[1]);\n return index;\n}\nfunction catchupLine(writer, lastLine, line) {\n do {\n writer.write(semicolon);\n } while (++lastLine < line);\n}\n\n// src/sourcemap-codec.ts\nfunction decode(mappings) {\n const { length } = mappings;\n const reader = new StringReader(mappings);\n const decoded = [];\n let genColumn = 0;\n let sourcesIndex = 0;\n let sourceLine = 0;\n let sourceColumn = 0;\n let namesIndex = 0;\n do {\n const semi = reader.indexOf(\";\");\n const line = [];\n let sorted = true;\n let lastCol = 0;\n genColumn = 0;\n while (reader.pos < semi) {\n let seg;\n genColumn = decodeInteger(reader, genColumn);\n if (genColumn < lastCol) sorted = false;\n lastCol = genColumn;\n if (hasMoreVlq(reader, semi)) {\n sourcesIndex = decodeInteger(reader, sourcesIndex);\n sourceLine = decodeInteger(reader, sourceLine);\n sourceColumn = decodeInteger(reader, sourceColumn);\n if (hasMoreVlq(reader, semi)) {\n namesIndex = decodeInteger(reader, namesIndex);\n seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];\n } else {\n seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];\n }\n } else {\n seg = [genColumn];\n }\n line.push(seg);\n reader.pos++;\n }\n if (!sorted) sort(line);\n decoded.push(line);\n reader.pos = semi + 1;\n } while (reader.pos <= length);\n return decoded;\n}\nfunction sort(line) {\n line.sort(sortComparator);\n}\nfunction sortComparator(a, b) {\n return a[0] - b[0];\n}\nfunction encode(decoded) {\n const writer = new StringWriter();\n let sourcesIndex = 0;\n let sourceLine = 0;\n let sourceColumn = 0;\n let namesIndex = 0;\n for (let i = 0; i < decoded.length; i++) {\n const line = decoded[i];\n if (i > 0) writer.write(semicolon);\n if (line.length === 0) continue;\n let genColumn = 0;\n for (let j = 0; j < line.length; j++) {\n const segment = line[j];\n if (j > 0) writer.write(comma);\n genColumn = encodeInteger(writer, segment[0], genColumn);\n if (segment.length === 1) continue;\n sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);\n sourceLine = encodeInteger(writer, segment[2], sourceLine);\n sourceColumn = encodeInteger(writer, segment[3], sourceColumn);\n if (segment.length === 4) continue;\n namesIndex = encodeInteger(writer, segment[4], namesIndex);\n }\n }\n return writer.flush();\n}\nexport {\n decode,\n decodeGeneratedRanges,\n decodeOriginalScopes,\n encode,\n encodeGeneratedRanges,\n encodeOriginalScopes\n};\n//# sourceMappingURL=sourcemap-codec.mjs.map\n","import { encode } from '@jridgewell/sourcemap-codec';\n\nfunction getBtoa() {\n\tif (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {\n\t\treturn (str) => globalThis.btoa(unescape(encodeURIComponent(str)));\n\t} else if (typeof Buffer === 'function') {\n\t\treturn (str) => Buffer.from(str, 'utf-8').toString('base64');\n\t} else {\n\t\treturn () => {\n\t\t\tthrow new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');\n\t\t};\n\t}\n}\n\nconst btoa = /*#__PURE__*/ getBtoa();\n\nexport default class SourceMap {\n\tconstructor(properties) {\n\t\tthis.version = 3;\n\t\tthis.file = properties.file;\n\t\tthis.sources = properties.sources;\n\t\tthis.sourcesContent = properties.sourcesContent;\n\t\tthis.names = properties.names;\n\t\tthis.mappings = encode(properties.mappings);\n\t\tif (typeof properties.x_google_ignoreList !== 'undefined') {\n\t\t\tthis.x_google_ignoreList = properties.x_google_ignoreList;\n\t\t}\n\t\tif (typeof properties.debugId !== 'undefined') {\n\t\t\tthis.debugId = properties.debugId;\n\t\t}\n\t}\n\n\ttoString() {\n\t\treturn JSON.stringify(this);\n\t}\n\n\ttoUrl() {\n\t\treturn 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());\n\t}\n}\n","export default function guessIndent(code) {\n\tconst lines = code.split('\\n');\n\n\tconst tabbed = lines.filter((line) => /^\\t+/.test(line));\n\tconst spaced = lines.filter((line) => /^ {2,}/.test(line));\n\n\tif (tabbed.length === 0 && spaced.length === 0) {\n\t\treturn null;\n\t}\n\n\t// More lines tabbed than spaced? Assume tabs, and\n\t// default to tabs in the case of a tie (or nothing\n\t// to go on)\n\tif (tabbed.length >= spaced.length) {\n\t\treturn '\\t';\n\t}\n\n\t// Otherwise, we need to guess the multiple\n\tconst min = spaced.reduce((previous, current) => {\n\t\tconst numSpaces = /^ +/.exec(current)[0].length;\n\t\treturn Math.min(numSpaces, previous);\n\t}, Infinity);\n\n\treturn new Array(min + 1).join(' ');\n}\n","export default function getRelativePath(from, to) {\n\tconst fromParts = from.split(/[/\\\\]/);\n\tconst toParts = to.split(/[/\\\\]/);\n\n\tfromParts.pop(); // get dirname\n\n\twhile (fromParts[0] === toParts[0]) {\n\t\tfromParts.shift();\n\t\ttoParts.shift();\n\t}\n\n\tif (fromParts.length) {\n\t\tlet i = fromParts.length;\n\t\twhile (i--) fromParts[i] = '..';\n\t}\n\n\treturn fromParts.concat(toParts).join('/');\n}\n","const toString = Object.prototype.toString;\n\nexport default function isObject(thing) {\n\treturn toString.call(thing) === '[object Object]';\n}\n","export default function getLocator(source) {\n\tconst originalLines = source.split('\\n');\n\tconst lineOffsets = [];\n\n\tfor (let i = 0, pos = 0; i < originalLines.length; i++) {\n\t\tlineOffsets.push(pos);\n\t\tpos += originalLines[i].length + 1;\n\t}\n\n\treturn function locate(index) {\n\t\tlet i = 0;\n\t\tlet j = lineOffsets.length;\n\t\twhile (i < j) {\n\t\t\tconst m = (i + j) >> 1;\n\t\t\tif (index < lineOffsets[m]) {\n\t\t\t\tj = m;\n\t\t\t} else {\n\t\t\t\ti = m + 1;\n\t\t\t}\n\t\t}\n\t\tconst line = i - 1;\n\t\tconst column = index - lineOffsets[line];\n\t\treturn { line, column };\n\t};\n}\n","const wordRegex = /\\w/;\n\nexport default class Mappings {\n\tconstructor(hires) {\n\t\tthis.hires = hires;\n\t\tthis.generatedCodeLine = 0;\n\t\tthis.generatedCodeColumn = 0;\n\t\tthis.raw = [];\n\t\tthis.rawSegments = this.raw[this.generatedCodeLine] = [];\n\t\tthis.pending = null;\n\t}\n\n\taddEdit(sourceIndex, content, loc, nameIndex) {\n\t\tif (content.length) {\n\t\t\tconst contentLengthMinusOne = content.length - 1;\n\t\t\tlet contentLineEnd = content.indexOf('\\n', 0);\n\t\t\tlet previousContentLineEnd = -1;\n\t\t\t// Loop through each line in the content and add a segment, but stop if the last line is empty,\n\t\t\t// else code afterwards would fill one line too many\n\t\t\twhile (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {\n\t\t\t\tconst segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];\n\t\t\t\tif (nameIndex >= 0) {\n\t\t\t\t\tsegment.push(nameIndex);\n\t\t\t\t}\n\t\t\t\tthis.rawSegments.push(segment);\n\n\t\t\t\tthis.generatedCodeLine += 1;\n\t\t\t\tthis.raw[this.generatedCodeLine] = this.rawSegments = [];\n\t\t\t\tthis.generatedCodeColumn = 0;\n\n\t\t\t\tpreviousContentLineEnd = contentLineEnd;\n\t\t\t\tcontentLineEnd = content.indexOf('\\n', contentLineEnd + 1);\n\t\t\t}\n\n\t\t\tconst segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];\n\t\t\tif (nameIndex >= 0) {\n\t\t\t\tsegment.push(nameIndex);\n\t\t\t}\n\t\t\tthis.rawSegments.push(segment);\n\n\t\t\tthis.advance(content.slice(previousContentLineEnd + 1));\n\t\t} else if (this.pending) {\n\t\t\tthis.rawSegments.push(this.pending);\n\t\t\tthis.advance(content);\n\t\t}\n\n\t\tthis.pending = null;\n\t}\n\n\taddUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {\n\t\tlet originalCharIndex = chunk.start;\n\t\tlet first = true;\n\t\t// when iterating each char, check if it's in a word boundary\n\t\tlet charInHiresBoundary = false;\n\n\t\twhile (originalCharIndex < chunk.end) {\n\t\t\tif (original[originalCharIndex] === '\\n') {\n\t\t\t\tloc.line += 1;\n\t\t\t\tloc.column = 0;\n\t\t\t\tthis.generatedCodeLine += 1;\n\t\t\t\tthis.raw[this.generatedCodeLine] = this.rawSegments = [];\n\t\t\t\tthis.generatedCodeColumn = 0;\n\t\t\t\tfirst = true;\n\t\t\t\tcharInHiresBoundary = false;\n\t\t\t} else {\n\t\t\t\tif (this.hires || first || sourcemapLocations.has(originalCharIndex)) {\n\t\t\t\t\tconst segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];\n\n\t\t\t\t\tif (this.hires === 'boundary') {\n\t\t\t\t\t\t// in hires \"boundary\", group segments per word boundary than per char\n\t\t\t\t\t\tif (wordRegex.test(original[originalCharIndex])) {\n\t\t\t\t\t\t\t// for first char in the boundary found, start the boundary by pushing a segment\n\t\t\t\t\t\t\tif (!charInHiresBoundary) {\n\t\t\t\t\t\t\t\tthis.rawSegments.push(segment);\n\t\t\t\t\t\t\t\tcharInHiresBoundary = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// for non-word char, end the boundary by pushing a segment\n\t\t\t\t\t\t\tthis.rawSegments.push(segment);\n\t\t\t\t\t\t\tcharInHiresBoundary = false;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.rawSegments.push(segment);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tloc.column += 1;\n\t\t\t\tthis.generatedCodeColumn += 1;\n\t\t\t\tfirst = false;\n\t\t\t}\n\n\t\t\toriginalCharIndex += 1;\n\t\t}\n\n\t\tthis.pending = null;\n\t}\n\n\tadvance(str) {\n\t\tif (!str) return;\n\n\t\tconst lines = str.split('\\n');\n\n\t\tif (lines.length > 1) {\n\t\t\tfor (let i = 0; i < lines.length - 1; i++) {\n\t\t\t\tthis.generatedCodeLine++;\n\t\t\t\tthis.raw[this.generatedCodeLine] = this.rawSegments = [];\n\t\t\t}\n\t\t\tthis.generatedCodeColumn = 0;\n\t\t}\n\n\t\tthis.generatedCodeColumn += lines[lines.length - 1].length;\n\t}\n}\n","import BitSet from './BitSet.js';\nimport Chunk from './Chunk.js';\nimport SourceMap from './SourceMap.js';\nimport guessIndent from './utils/guessIndent.js';\nimport getRelativePath from './utils/getRelativePath.js';\nimport isObject from './utils/isObject.js';\nimport getLocator from './utils/getLocator.js';\nimport Mappings from './utils/Mappings.js';\nimport Stats from './utils/Stats.js';\n\nconst n = '\\n';\n\nconst warned = {\n\tinsertLeft: false,\n\tinsertRight: false,\n\tstoreName: false,\n};\n\nexport default class MagicString {\n\tconstructor(string, options = {}) {\n\t\tconst chunk = new Chunk(0, string.length, string);\n\n\t\tObject.defineProperties(this, {\n\t\t\toriginal: { writable: true, value: string },\n\t\t\toutro: { writable: true, value: '' },\n\t\t\tintro: { writable: true, value: '' },\n\t\t\tfirstChunk: { writable: true, value: chunk },\n\t\t\tlastChunk: { writable: true, value: chunk },\n\t\t\tlastSearchedChunk: { writable: true, value: chunk },\n\t\t\tbyStart: { writable: true, value: {} },\n\t\t\tbyEnd: { writable: true, value: {} },\n\t\t\tfilename: { writable: true, value: options.filename },\n\t\t\tindentExclusionRanges: { writable: true, value: options.indentExclusionRanges },\n\t\t\tsourcemapLocations: { writable: true, value: new BitSet() },\n\t\t\tstoredNames: { writable: true, value: {} },\n\t\t\tindentStr: { writable: true, value: undefined },\n\t\t\tignoreList: { writable: true, value: options.ignoreList },\n\t\t\toffset: { writable: true, value: options.offset || 0 },\n\t\t});\n\n\t\tif (DEBUG) {\n\t\t\tObject.defineProperty(this, 'stats', { value: new Stats() });\n\t\t}\n\n\t\tthis.byStart[0] = chunk;\n\t\tthis.byEnd[string.length] = chunk;\n\t}\n\n\taddSourcemapLocation(char) {\n\t\tthis.sourcemapLocations.add(char);\n\t}\n\n\tappend(content) {\n\t\tif (typeof content !== 'string') throw new TypeError('outro content must be a string');\n\n\t\tthis.outro += content;\n\t\treturn this;\n\t}\n\n\tappendLeft(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('appendLeft');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byEnd[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.appendLeft(content);\n\t\t} else {\n\t\t\tthis.intro += content;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('appendLeft');\n\t\treturn this;\n\t}\n\n\tappendRight(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('appendRight');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byStart[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.appendRight(content);\n\t\t} else {\n\t\t\tthis.outro += content;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('appendRight');\n\t\treturn this;\n\t}\n\n\tclone() {\n\t\tconst cloned = new MagicString(this.original, { filename: this.filename, offset: this.offset });\n\n\t\tlet originalChunk = this.firstChunk;\n\t\tlet clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());\n\n\t\twhile (originalChunk) {\n\t\t\tcloned.byStart[clonedChunk.start] = clonedChunk;\n\t\t\tcloned.byEnd[clonedChunk.end] = clonedChunk;\n\n\t\t\tconst nextOriginalChunk = originalChunk.next;\n\t\t\tconst nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();\n\n\t\t\tif (nextClonedChunk) {\n\t\t\t\tclonedChunk.next = nextClonedChunk;\n\t\t\t\tnextClonedChunk.previous = clonedChunk;\n\n\t\t\t\tclonedChunk = nextClonedChunk;\n\t\t\t}\n\n\t\t\toriginalChunk = nextOriginalChunk;\n\t\t}\n\n\t\tcloned.lastChunk = clonedChunk;\n\n\t\tif (this.indentExclusionRanges) {\n\t\t\tcloned.indentExclusionRanges = this.indentExclusionRanges.slice();\n\t\t}\n\n\t\tcloned.sourcemapLocations = new BitSet(this.sourcemapLocations);\n\n\t\tcloned.intro = this.intro;\n\t\tcloned.outro = this.outro;\n\n\t\treturn cloned;\n\t}\n\n\tgenerateDecodedMap(options) {\n\t\toptions = options || {};\n\n\t\tconst sourceIndex = 0;\n\t\tconst names = Object.keys(this.storedNames);\n\t\tconst mappings = new Mappings(options.hires);\n\n\t\tconst locate = getLocator(this.original);\n\n\t\tif (this.intro) {\n\t\t\tmappings.advance(this.intro);\n\t\t}\n\n\t\tthis.firstChunk.eachNext((chunk) => {\n\t\t\tconst loc = locate(chunk.start);\n\n\t\t\tif (chunk.intro.length) mappings.advance(chunk.intro);\n\n\t\t\tif (chunk.edited) {\n\t\t\t\tmappings.addEdit(\n\t\t\t\t\tsourceIndex,\n\t\t\t\t\tchunk.content,\n\t\t\t\t\tloc,\n\t\t\t\t\tchunk.storeName ? names.indexOf(chunk.original) : -1,\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tmappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);\n\t\t\t}\n\n\t\t\tif (chunk.outro.length) mappings.advance(chunk.outro);\n\t\t});\n\n\t\tif (this.outro) {\n\t\t\tmappings.advance(this.outro);\n\t\t}\n\n\t\treturn {\n\t\t\tfile: options.file ? options.file.split(/[/\\\\]/).pop() : undefined,\n\t\t\tsources: [\n\t\t\t\toptions.source ? getRelativePath(options.file || '', options.source) : options.file || '',\n\t\t\t],\n\t\t\tsourcesContent: options.includeContent ? [this.original] : undefined,\n\t\t\tnames,\n\t\t\tmappings: mappings.raw,\n\t\t\tx_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,\n\t\t};\n\t}\n\n\tgenerateMap(options) {\n\t\treturn new SourceMap(this.generateDecodedMap(options));\n\t}\n\n\t_ensureindentStr() {\n\t\tif (this.indentStr === undefined) {\n\t\t\tthis.indentStr = guessIndent(this.original);\n\t\t}\n\t}\n\n\t_getRawIndentString() {\n\t\tthis._ensureindentStr();\n\t\treturn this.indentStr;\n\t}\n\n\tgetIndentString() {\n\t\tthis._ensureindentStr();\n\t\treturn this.indentStr === null ? '\\t' : this.indentStr;\n\t}\n\n\tindent(indentStr, options) {\n\t\tconst pattern = /^[^\\r\\n]/gm;\n\n\t\tif (isObject(indentStr)) {\n\t\t\toptions = indentStr;\n\t\t\tindentStr = undefined;\n\t\t}\n\n\t\tif (indentStr === undefined) {\n\t\t\tthis._ensureindentStr();\n\t\t\tindentStr = this.indentStr || '\\t';\n\t\t}\n\n\t\tif (indentStr === '') return this; // noop\n\n\t\toptions = options || {};\n\n\t\t// Process exclusion ranges\n\t\tconst isExcluded = {};\n\n\t\tif (options.exclude) {\n\t\t\tconst exclusions =\n\t\t\t\ttypeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;\n\t\t\texclusions.forEach((exclusion) => {\n\t\t\t\tfor (let i = exclusion[0]; i < exclusion[1]; i += 1) {\n\t\t\t\t\tisExcluded[i] = true;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\tlet shouldIndentNextCharacter = options.indentStart !== false;\n\t\tconst replacer = (match) => {\n\t\t\tif (shouldIndentNextCharacter) return `${indentStr}${match}`;\n\t\t\tshouldIndentNextCharacter = true;\n\t\t\treturn match;\n\t\t};\n\n\t\tthis.intro = this.intro.replace(pattern, replacer);\n\n\t\tlet charIndex = 0;\n\t\tlet chunk = this.firstChunk;\n\n\t\twhile (chunk) {\n\t\t\tconst end = chunk.end;\n\n\t\t\tif (chunk.edited) {\n\t\t\t\tif (!isExcluded[charIndex]) {\n\t\t\t\t\tchunk.content = chunk.content.replace(pattern, replacer);\n\n\t\t\t\t\tif (chunk.content.length) {\n\t\t\t\t\t\tshouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\\n';\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcharIndex = chunk.start;\n\n\t\t\t\twhile (charIndex < end) {\n\t\t\t\t\tif (!isExcluded[charIndex]) {\n\t\t\t\t\t\tconst char = this.original[charIndex];\n\n\t\t\t\t\t\tif (char === '\\n') {\n\t\t\t\t\t\t\tshouldIndentNextCharacter = true;\n\t\t\t\t\t\t} else if (char !== '\\r' && shouldIndentNextCharacter) {\n\t\t\t\t\t\t\tshouldIndentNextCharacter = false;\n\n\t\t\t\t\t\t\tif (charIndex === chunk.start) {\n\t\t\t\t\t\t\t\tchunk.prependRight(indentStr);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis._splitChunk(chunk, charIndex);\n\t\t\t\t\t\t\t\tchunk = chunk.next;\n\t\t\t\t\t\t\t\tchunk.prependRight(indentStr);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tcharIndex += 1;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tcharIndex = chunk.end;\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\tthis.outro = this.outro.replace(pattern, replacer);\n\n\t\treturn this;\n\t}\n\n\tinsert() {\n\t\tthrow new Error(\n\t\t\t'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',\n\t\t);\n\t}\n\n\tinsertLeft(index, content) {\n\t\tif (!warned.insertLeft) {\n\t\t\tconsole.warn(\n\t\t\t\t'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',\n\t\t\t);\n\t\t\twarned.insertLeft = true;\n\t\t}\n\n\t\treturn this.appendLeft(index, content);\n\t}\n\n\tinsertRight(index, content) {\n\t\tif (!warned.insertRight) {\n\t\t\tconsole.warn(\n\t\t\t\t'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',\n\t\t\t);\n\t\t\twarned.insertRight = true;\n\t\t}\n\n\t\treturn this.prependRight(index, content);\n\t}\n\n\tmove(start, end, index) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\t\tindex = index + this.offset;\n\n\t\tif (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');\n\n\t\tif (DEBUG) this.stats.time('move');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\t\tthis._split(index);\n\n\t\tconst first = this.byStart[start];\n\t\tconst last = this.byEnd[end];\n\n\t\tconst oldLeft = first.previous;\n\t\tconst oldRight = last.next;\n\n\t\tconst newRight = this.byStart[index];\n\t\tif (!newRight && last === this.lastChunk) return this;\n\t\tconst newLeft = newRight ? newRight.previous : this.lastChunk;\n\n\t\tif (oldLeft) oldLeft.next = oldRight;\n\t\tif (oldRight) oldRight.previous = oldLeft;\n\n\t\tif (newLeft) newLeft.next = first;\n\t\tif (newRight) newRight.previous = last;\n\n\t\tif (!first.previous) this.firstChunk = last.next;\n\t\tif (!last.next) {\n\t\t\tthis.lastChunk = first.previous;\n\t\t\tthis.lastChunk.next = null;\n\t\t}\n\n\t\tfirst.previous = newLeft;\n\t\tlast.next = newRight || null;\n\n\t\tif (!newLeft) this.firstChunk = first;\n\t\tif (!newRight) this.lastChunk = last;\n\n\t\tif (DEBUG) this.stats.timeEnd('move');\n\t\treturn this;\n\t}\n\n\toverwrite(start, end, content, options) {\n\t\toptions = options || {};\n\t\treturn this.update(start, end, content, { ...options, overwrite: !options.contentOnly });\n\t}\n\n\tupdate(start, end, content, options) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('replacement content must be a string');\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tif (end > this.original.length) throw new Error('end is out of bounds');\n\t\tif (start === end)\n\t\t\tthrow new Error(\n\t\t\t\t'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',\n\t\t\t);\n\n\t\tif (DEBUG) this.stats.time('overwrite');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\n\t\tif (options === true) {\n\t\t\tif (!warned.storeName) {\n\t\t\t\tconsole.warn(\n\t\t\t\t\t'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',\n\t\t\t\t);\n\t\t\t\twarned.storeName = true;\n\t\t\t}\n\n\t\t\toptions = { storeName: true };\n\t\t}\n\t\tconst storeName = options !== undefined ? options.storeName : false;\n\t\tconst overwrite = options !== undefined ? options.overwrite : false;\n\n\t\tif (storeName) {\n\t\t\tconst original = this.original.slice(start, end);\n\t\t\tObject.defineProperty(this.storedNames, original, {\n\t\t\t\twritable: true,\n\t\t\t\tvalue: true,\n\t\t\t\tenumerable: true,\n\t\t\t});\n\t\t}\n\n\t\tconst first = this.byStart[start];\n\t\tconst last = this.byEnd[end];\n\n\t\tif (first) {\n\t\t\tlet chunk = first;\n\t\t\twhile (chunk !== last) {\n\t\t\t\tif (chunk.next !== this.byStart[chunk.end]) {\n\t\t\t\t\tthrow new Error('Cannot overwrite across a split point');\n\t\t\t\t}\n\t\t\t\tchunk = chunk.next;\n\t\t\t\tchunk.edit('', false);\n\t\t\t}\n\n\t\t\tfirst.edit(content, storeName, !overwrite);\n\t\t} else {\n\t\t\t// must be inserting at the end\n\t\t\tconst newChunk = new Chunk(start, end, '').edit(content, storeName);\n\n\t\t\t// TODO last chunk in the array may not be the last chunk, if it's moved...\n\t\t\tlast.next = newChunk;\n\t\t\tnewChunk.previous = last;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('overwrite');\n\t\treturn this;\n\t}\n\n\tprepend(content) {\n\t\tif (typeof content !== 'string') throw new TypeError('outro content must be a string');\n\n\t\tthis.intro = content + this.intro;\n\t\treturn this;\n\t}\n\n\tprependLeft(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('insertRight');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byEnd[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.prependLeft(content);\n\t\t} else {\n\t\t\tthis.intro = content + this.intro;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('insertRight');\n\t\treturn this;\n\t}\n\n\tprependRight(index, content) {\n\t\tindex = index + this.offset;\n\n\t\tif (typeof content !== 'string') throw new TypeError('inserted content must be a string');\n\n\t\tif (DEBUG) this.stats.time('insertRight');\n\n\t\tthis._split(index);\n\n\t\tconst chunk = this.byStart[index];\n\n\t\tif (chunk) {\n\t\t\tchunk.prependRight(content);\n\t\t} else {\n\t\t\tthis.outro = content + this.outro;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('insertRight');\n\t\treturn this;\n\t}\n\n\tremove(start, end) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tif (start === end) return this;\n\n\t\tif (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');\n\t\tif (start > end) throw new Error('end must be greater than start');\n\n\t\tif (DEBUG) this.stats.time('remove');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\n\t\tlet chunk = this.byStart[start];\n\n\t\twhile (chunk) {\n\t\t\tchunk.intro = '';\n\t\t\tchunk.outro = '';\n\t\t\tchunk.edit('');\n\n\t\t\tchunk = end > chunk.end ? this.byStart[chunk.end] : null;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('remove');\n\t\treturn this;\n\t}\n\n\treset(start, end) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tif (start === end) return this;\n\n\t\tif (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');\n\t\tif (start > end) throw new Error('end must be greater than start');\n\n\t\tif (DEBUG) this.stats.time('reset');\n\n\t\tthis._split(start);\n\t\tthis._split(end);\n\n\t\tlet chunk = this.byStart[start];\n\n\t\twhile (chunk) {\n\t\t\tchunk.reset();\n\n\t\t\tchunk = end > chunk.end ? this.byStart[chunk.end] : null;\n\t\t}\n\n\t\tif (DEBUG) this.stats.timeEnd('reset');\n\t\treturn this;\n\t}\n\n\tlastChar() {\n\t\tif (this.outro.length) return this.outro[this.outro.length - 1];\n\t\tlet chunk = this.lastChunk;\n\t\tdo {\n\t\t\tif (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];\n\t\t\tif (chunk.content.length) return chunk.content[chunk.content.length - 1];\n\t\t\tif (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];\n\t\t} while ((chunk = chunk.previous));\n\t\tif (this.intro.length) return this.intro[this.intro.length - 1];\n\t\treturn '';\n\t}\n\n\tlastLine() {\n\t\tlet lineIndex = this.outro.lastIndexOf(n);\n\t\tif (lineIndex !== -1) return this.outro.substr(lineIndex + 1);\n\t\tlet lineStr = this.outro;\n\t\tlet chunk = this.lastChunk;\n\t\tdo {\n\t\t\tif (chunk.outro.length > 0) {\n\t\t\t\tlineIndex = chunk.outro.lastIndexOf(n);\n\t\t\t\tif (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;\n\t\t\t\tlineStr = chunk.outro + lineStr;\n\t\t\t}\n\n\t\t\tif (chunk.content.length > 0) {\n\t\t\t\tlineIndex = chunk.content.lastIndexOf(n);\n\t\t\t\tif (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;\n\t\t\t\tlineStr = chunk.content + lineStr;\n\t\t\t}\n\n\t\t\tif (chunk.intro.length > 0) {\n\t\t\t\tlineIndex = chunk.intro.lastIndexOf(n);\n\t\t\t\tif (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;\n\t\t\t\tlineStr = chunk.intro + lineStr;\n\t\t\t}\n\t\t} while ((chunk = chunk.previous));\n\t\tlineIndex = this.intro.lastIndexOf(n);\n\t\tif (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;\n\t\treturn this.intro + lineStr;\n\t}\n\n\tslice(start = 0, end = this.original.length - this.offset) {\n\t\tstart = start + this.offset;\n\t\tend = end + this.offset;\n\n\t\tif (this.original.length !== 0) {\n\t\t\twhile (start < 0) start += this.original.length;\n\t\t\twhile (end < 0) end += this.original.length;\n\t\t}\n\n\t\tlet result = '';\n\n\t\t// find start chunk\n\t\tlet chunk = this.firstChunk;\n\t\twhile (chunk && (chunk.start > start || chunk.end <= start)) {\n\t\t\t// found end chunk before start\n\t\t\tif (chunk.start < end && chunk.end >= end) {\n\t\t\t\treturn result;\n\t\t\t}\n\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\tif (chunk && chunk.edited && chunk.start !== start)\n\t\t\tthrow new Error(`Cannot use replaced character ${start} as slice start anchor.`);\n\n\t\tconst startChunk = chunk;\n\t\twhile (chunk) {\n\t\t\tif (chunk.intro && (startChunk !== chunk || chunk.start === start)) {\n\t\t\t\tresult += chunk.intro;\n\t\t\t}\n\n\t\t\tconst containsEnd = chunk.start < end && chunk.end >= end;\n\t\t\tif (containsEnd && chunk.edited && chunk.end !== end)\n\t\t\t\tthrow new Error(`Cannot use replaced character ${end} as slice end anchor.`);\n\n\t\t\tconst sliceStart = startChunk === chunk ? start - chunk.start : 0;\n\t\t\tconst sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;\n\n\t\t\tresult += chunk.content.slice(sliceStart, sliceEnd);\n\n\t\t\tif (chunk.outro && (!containsEnd || chunk.end === end)) {\n\t\t\t\tresult += chunk.outro;\n\t\t\t}\n\n\t\t\tif (containsEnd) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t// TODO deprecate this? not really very useful\n\tsnip(start, end) {\n\t\tconst clone = this.clone();\n\t\tclone.remove(0, start);\n\t\tclone.remove(end, clone.original.length);\n\n\t\treturn clone;\n\t}\n\n\t_split(index) {\n\t\tif (this.byStart[index] || this.byEnd[index]) return;\n\n\t\tif (DEBUG) this.stats.time('_split');\n\n\t\tlet chunk = this.lastSearchedChunk;\n\t\tlet previousChunk = chunk;\n\t\tconst searchForward = index > chunk.end;\n\n\t\twhile (chunk) {\n\t\t\tif (chunk.contains(index)) return this._splitChunk(chunk, index);\n\n\t\t\tchunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];\n\n\t\t\t// Prevent infinite loop (e.g. via empty chunks, where start === end)\n\t\t\tif (chunk === previousChunk) return;\n\n\t\t\tpreviousChunk = chunk;\n\t\t}\n\t}\n\n\t_splitChunk(chunk, index) {\n\t\tif (chunk.edited && chunk.content.length) {\n\t\t\t// zero-length edited chunks are a special case (overlapping replacements)\n\t\t\tconst loc = getLocator(this.original)(index);\n\t\t\tthrow new Error(\n\t\t\t\t`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – \"${chunk.original}\")`,\n\t\t\t);\n\t\t}\n\n\t\tconst newChunk = chunk.split(index);\n\n\t\tthis.byEnd[index] = chunk;\n\t\tthis.byStart[index] = newChunk;\n\t\tthis.byEnd[newChunk.end] = newChunk;\n\n\t\tif (chunk === this.lastChunk) this.lastChunk = newChunk;\n\n\t\tthis.lastSearchedChunk = chunk;\n\t\tif (DEBUG) this.stats.timeEnd('_split');\n\t\treturn true;\n\t}\n\n\ttoString() {\n\t\tlet str = this.intro;\n\n\t\tlet chunk = this.firstChunk;\n\t\twhile (chunk) {\n\t\t\tstr += chunk.toString();\n\t\t\tchunk = chunk.next;\n\t\t}\n\n\t\treturn str + this.outro;\n\t}\n\n\tisEmpty() {\n\t\tlet chunk = this.firstChunk;\n\t\tdo {\n\t\t\tif (\n\t\t\t\t(chunk.intro.length && chunk.intro.trim()) ||\n\t\t\t\t(chunk.content.length && chunk.content.trim()) ||\n\t\t\t\t(chunk.outro.length && chunk.outro.trim())\n\t\t\t)\n\t\t\t\treturn false;\n\t\t} while ((chunk = chunk.next));\n\t\treturn true;\n\t}\n\n\tlength() {\n\t\tlet chunk = this.firstChunk;\n\t\tlet length = 0;\n\t\tdo {\n\t\t\tlength += chunk.intro.length + chunk.content.length + chunk.outro.length;\n\t\t} while ((chunk = chunk.next));\n\t\treturn length;\n\t}\n\n\ttrimLines() {\n\t\treturn this.trim('[\\\\r\\\\n]');\n\t}\n\n\ttrim(charType) {\n\t\treturn this.trimStart(charType).trimEnd(charType);\n\t}\n\n\ttrimEndAborted(charType) {\n\t\tconst rx = new RegExp((charType || '\\\\s') + '+$');\n\n\t\tthis.outro = this.outro.replace(rx, '');\n\t\tif (this.outro.length) return true;\n\n\t\tlet chunk = this.lastChunk;\n\n\t\tdo {\n\t\t\tconst end = chunk.end;\n\t\t\tconst aborted = chunk.trimEnd(rx);\n\n\t\t\t// if chunk was trimmed, we have a new lastChunk\n\t\t\tif (chunk.end !== end) {\n\t\t\t\tif (this.lastChunk === chunk) {\n\t\t\t\t\tthis.lastChunk = chunk.next;\n\t\t\t\t}\n\n\t\t\t\tthis.byEnd[chunk.end] = chunk;\n\t\t\t\tthis.byStart[chunk.next.start] = chunk.next;\n\t\t\t\tthis.byEnd[chunk.next.end] = chunk.next;\n\t\t\t}\n\n\t\t\tif (aborted) return true;\n\t\t\tchunk = chunk.previous;\n\t\t} while (chunk);\n\n\t\treturn false;\n\t}\n\n\ttrimEnd(charType) {\n\t\tthis.trimEndAborted(charType);\n\t\treturn this;\n\t}\n\ttrimStartAborted(charType) {\n\t\tconst rx = new RegExp('^' + (charType || '\\\\s') + '+');\n\n\t\tthis.intro = this.intro.replace(rx, '');\n\t\tif (this.intro.length) return true;\n\n\t\tlet chunk = this.firstChunk;\n\n\t\tdo {\n\t\t\tconst end = chunk.end;\n\t\t\tconst aborted = chunk.trimStart(rx);\n\n\t\t\tif (chunk.end !== end) {\n\t\t\t\t// special case...\n\t\t\t\tif (chunk === this.lastChunk) this.lastChunk = chunk.next;\n\n\t\t\t\tthis.byEnd[chunk.end] = chunk;\n\t\t\t\tthis.byStart[chunk.next.start] = chunk.next;\n\t\t\t\tthis.byEnd[chunk.next.end] = chunk.next;\n\t\t\t}\n\n\t\t\tif (aborted) return true;\n\t\t\tchunk = chunk.next;\n\t\t} while (chunk);\n\n\t\treturn false;\n\t}\n\n\ttrimStart(charType) {\n\t\tthis.trimStartAborted(charType);\n\t\treturn this;\n\t}\n\n\thasChanged() {\n\t\treturn this.original !== this.toString();\n\t}\n\n\t_replaceRegexp(searchValue, replacement) {\n\t\tfunction getReplacement(match, str) {\n\t\t\tif (typeof replacement === 'string') {\n\t\t\t\treturn replacement.replace(/\\$(\\$|&|\\d+)/g, (_, i) => {\n\t\t\t\t\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter\n\t\t\t\t\tif (i === '$') return '$';\n\t\t\t\t\tif (i === '&') return match[0];\n\t\t\t\t\tconst num = +i;\n\t\t\t\t\tif (num < match.length) return match[+i];\n\t\t\t\t\treturn `$${i}`;\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\treturn replacement(...match, match.index, str, match.groups);\n\t\t\t}\n\t\t}\n\t\tfunction matchAll(re, str) {\n\t\t\tlet match;\n\t\t\tconst matches = [];\n\t\t\twhile ((match = re.exec(str))) {\n\t\t\t\tmatches.push(match);\n\t\t\t}\n\t\t\treturn matches;\n\t\t}\n\t\tif (searchValue.global) {\n\t\t\tconst matches = matchAll(searchValue, this.original);\n\t\t\tmatches.forEach((match) => {\n\t\t\t\tif (match.index != null) {\n\t\t\t\t\tconst replacement = getReplacement(match, this.original);\n\t\t\t\t\tif (replacement !== match[0]) {\n\t\t\t\t\t\tthis.overwrite(match.index, match.index + match[0].length, replacement);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t} else {\n\t\t\tconst match = this.original.match(searchValue);\n\t\t\tif (match && match.index != null) {\n\t\t\t\tconst replacement = getReplacement(match, this.original);\n\t\t\t\tif (replacement !== match[0]) {\n\t\t\t\t\tthis.overwrite(match.index, match.index + match[0].length, replacement);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t_replaceString(string, replacement) {\n\t\tconst { original } = this;\n\t\tconst index = original.indexOf(string);\n\n\t\tif (index !== -1) {\n\t\t\tif (typeof replacement === 'function') {\n\t\t\t\treplacement = replacement(string, index, original);\n\t\t\t}\n\t\t\tif (string !== replacement) {\n\t\t\t\tthis.overwrite(index, index + string.length, replacement);\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t}\n\n\treplace(searchValue, replacement) {\n\t\tif (typeof searchValue === 'string') {\n\t\t\treturn this._replaceString(searchValue, replacement);\n\t\t}\n\n\t\treturn this._replaceRegexp(searchValue, replacement);\n\t}\n\n\t_replaceAllString(string, replacement) {\n\t\tconst { original } = this;\n\t\tconst stringLength = string.length;\n\t\tfor (\n\t\t\tlet index = original.indexOf(string);\n\t\t\tindex !== -1;\n\t\t\tindex = original.indexOf(string, index + stringLength)\n\t\t) {\n\t\t\tconst previous = original.slice(index, index + stringLength);\n\t\t\tlet _replacement = replacement;\n\t\t\tif (typeof replacement === 'function') {\n\t\t\t\t_replacement = replacement(previous, index, original);\n\t\t\t}\n\t\t\tif (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);\n\t\t}\n\n\t\treturn this;\n\t}\n\n\treplaceAll(searchValue, replacement) {\n\t\tif (typeof searchValue === 'string') {\n\t\t\treturn this._replaceAllString(searchValue, replacement);\n\t\t}\n\n\t\tif (!searchValue.global) {\n\t\t\tthrow new TypeError(\n\t\t\t\t'MagicString.prototype.replaceAll called with a non-global RegExp argument',\n\t\t\t);\n\t\t}\n\n\t\treturn this._replaceRegexp(searchValue, replacement);\n\t}\n}\n","import MagicString from './MagicString.js';\nimport SourceMap from './SourceMap.js';\nimport getRelativePath from './utils/getRelativePath.js';\nimport isObject from './utils/isObject.js';\nimport getLocator from './utils/getLocator.js';\nimport Mappings from './utils/Mappings.js';\n\nconst hasOwnProp = Object.prototype.hasOwnProperty;\n\nexport default class Bundle {\n\tconstructor(options = {}) {\n\t\tthis.intro = options.intro || '';\n\t\tthis.separator = options.separator !== undefined ? options.separator : '\\n';\n\t\tthis.sources = [];\n\t\tthis.uniqueSources = [];\n\t\tthis.uniqueSourceIndexByFilename = {};\n\t}\n\n\taddSource(source) {\n\t\tif (source instanceof MagicString) {\n\t\t\treturn this.addSource({\n\t\t\t\tcontent: source,\n\t\t\t\tfilename: source.filename,\n\t\t\t\tseparator: this.separator,\n\t\t\t});\n\t\t}\n\n\t\tif (!isObject(source) || !source.content) {\n\t\t\tthrow new Error(\n\t\t\t\t'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`',\n\t\t\t);\n\t\t}\n\n\t\t['filename', 'ignoreList', 'indentExclusionRanges', 'separator'].forEach((option) => {\n\t\t\tif (!hasOwnProp.call(source, option)) source[option] = source.content[option];\n\t\t});\n\n\t\tif (source.separator === undefined) {\n\t\t\t// TODO there's a bunch of this sort of thing, needs cleaning up\n\t\t\tsource.separator = this.separator;\n\t\t}\n\n\t\tif (source.filename) {\n\t\t\tif (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {\n\t\t\t\tthis.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;\n\t\t\t\tthis.uniqueSources.push({ filename: source.filename, content: source.content.original });\n\t\t\t} else {\n\t\t\t\tconst uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];\n\t\t\t\tif (source.content.original !== uniqueSource.content) {\n\t\t\t\t\tthrow new Error(`Illegal source: same filename (${source.filename}), different contents`);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tthis.sources.push(source);\n\t\treturn this;\n\t}\n\n\tappend(str, options) {\n\t\tthis.addSource({\n\t\t\tcontent: new MagicString(str),\n\t\t\tseparator: (options && options.separator) || '',\n\t\t});\n\n\t\treturn this;\n\t}\n\n\tclone() {\n\t\tconst bundle = new Bundle({\n\t\t\tintro: this.intro,\n\t\t\tseparator: this.separator,\n\t\t});\n\n\t\tthis.sources.forEach((source) => {\n\t\t\tbundle.addSource({\n\t\t\t\tfilename: source.filename,\n\t\t\t\tcontent: source.content.clone(),\n\t\t\t\tseparator: source.separator,\n\t\t\t});\n\t\t});\n\n\t\treturn bundle;\n\t}\n\n\tgenerateDecodedMap(options = {}) {\n\t\tconst names = [];\n\t\tlet x_google_ignoreList = undefined;\n\t\tthis.sources.forEach((source) => {\n\t\t\tObject.keys(source.content.storedNames).forEach((name) => {\n\t\t\t\tif (!~names.indexOf(name)) names.push(name);\n\t\t\t});\n\t\t});\n\n\t\tconst mappings = new Mappings(options.hires);\n\n\t\tif (this.intro) {\n\t\t\tmappings.advance(this.intro);\n\t\t}\n\n\t\tthis.sources.forEach((source, i) => {\n\t\t\tif (i > 0) {\n\t\t\t\tmappings.advance(this.separator);\n\t\t\t}\n\n\t\t\tconst sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1;\n\t\t\tconst magicString = source.content;\n\t\t\tconst locate = getLocator(magicString.original);\n\n\t\t\tif (magicString.intro) {\n\t\t\t\tmappings.advance(magicString.intro);\n\t\t\t}\n\n\t\t\tmagicString.firstChunk.eachNext((chunk) => {\n\t\t\t\tconst loc = locate(chunk.start);\n\n\t\t\t\tif (chunk.intro.length) mappings.advance(chunk.intro);\n\n\t\t\t\tif (source.filename) {\n\t\t\t\t\tif (chunk.edited) {\n\t\t\t\t\t\tmappings.addEdit(\n\t\t\t\t\t\t\tsourceIndex,\n\t\t\t\t\t\t\tchunk.content,\n\t\t\t\t\t\t\tloc,\n\t\t\t\t\t\t\tchunk.storeName ? names.indexOf(chunk.original) : -1,\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tmappings.addUneditedChunk(\n\t\t\t\t\t\t\tsourceIndex,\n\t\t\t\t\t\t\tchunk,\n\t\t\t\t\t\t\tmagicString.original,\n\t\t\t\t\t\t\tloc,\n\t\t\t\t\t\t\tmagicString.sourcemapLocations,\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tmappings.advance(chunk.content);\n\t\t\t\t}\n\n\t\t\t\tif (chunk.outro.length) mappings.advance(chunk.outro);\n\t\t\t});\n\n\t\t\tif (magicString.outro) {\n\t\t\t\tmappings.advance(magicString.outro);\n\t\t\t}\n\n\t\t\tif (source.ignoreList && sourceIndex !== -1) {\n\t\t\t\tif (x_google_ignoreList === undefined) {\n\t\t\t\t\tx_google_ignoreList = [];\n\t\t\t\t}\n\t\t\t\tx_google_ignoreList.push(sourceIndex);\n\t\t\t}\n\t\t});\n\n\t\treturn {\n\t\t\tfile: options.file ? options.file.split(/[/\\\\]/).pop() : undefined,\n\t\t\tsources: this.uniqueSources.map((source) => {\n\t\t\t\treturn options.file ? getRelativePath(options.file, source.filename) : source.filename;\n\t\t\t}),\n\t\t\tsourcesContent: this.uniqueSources.map((source) => {\n\t\t\t\treturn options.includeContent ? source.content : null;\n\t\t\t}),\n\t\t\tnames,\n\t\t\tmappings: mappings.raw,\n\t\t\tx_google_ignoreList,\n\t\t};\n\t}\n\n\tgenerateMap(options) {\n\t\treturn new SourceMap(this.generateDecodedMap(options));\n\t}\n\n\tgetIndentString() {\n\t\tconst indentStringCounts = {};\n\n\t\tthis.sources.forEach((source) => {\n\t\t\tconst indentStr = source.content._getRawIndentString();\n\n\t\t\tif (indentStr === null) return;\n\n\t\t\tif (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0;\n\t\t\tindentStringCounts[indentStr] += 1;\n\t\t});\n\n\t\treturn (\n\t\t\tObject.keys(indentStringCounts).sort((a, b) => {\n\t\t\t\treturn indentStringCounts[a] - indentStringCounts[b];\n\t\t\t})[0] || '\\t'\n\t\t);\n\t}\n\n\tindent(indentStr) {\n\t\tif (!arguments.length) {\n\t\t\tindentStr = this.getIndentString();\n\t\t}\n\n\t\tif (indentStr === '') return this; // noop\n\n\t\tlet trailingNewline = !this.intro || this.intro.slice(-1) === '\\n';\n\n\t\tthis.sources.forEach((source, i) => {\n\t\t\tconst separator = source.separator !== undefined ? source.separator : this.separator;\n\t\t\tconst indentStart = trailingNewline || (i > 0 && /\\r?\\n$/.test(separator));\n\n\t\t\tsource.content.indent(indentStr, {\n\t\t\t\texclude: source.indentExclusionRanges,\n\t\t\t\tindentStart, //: trailingNewline || /\\r?\\n$/.test( separator ) //true///\\r?\\n/.test( separator )\n\t\t\t});\n\n\t\t\ttrailingNewline = source.content.lastChar() === '\\n';\n\t\t});\n\n\t\tif (this.intro) {\n\t\t\tthis.intro =\n\t\t\t\tindentStr +\n\t\t\t\tthis.intro.replace(/^[^\\n]/gm, (match, index) => {\n\t\t\t\t\treturn index > 0 ? indentStr + match : match;\n\t\t\t\t});\n\t\t}\n\n\t\treturn this;\n\t}\n\n\tprepend(str) {\n\t\tthis.intro = str + this.intro;\n\t\treturn this;\n\t}\n\n\ttoString() {\n\t\tconst body = this.sources\n\t\t\t.map((source, i) => {\n\t\t\t\tconst separator = source.separator !== undefined ? source.separator : this.separator;\n\t\t\t\tconst str = (i > 0 ? separator : '') + source.content.toString();\n\n\t\t\t\treturn str;\n\t\t\t})\n\t\t\t.join('');\n\n\t\treturn this.intro + body;\n\t}\n\n\tisEmpty() {\n\t\tif (this.intro.length && this.intro.trim()) return false;\n\t\tif (this.sources.some((source) => !source.content.isEmpty())) return false;\n\t\treturn true;\n\t}\n\n\tlength() {\n\t\treturn this.sources.reduce(\n\t\t\t(length, source) => length + source.content.length(),\n\t\t\tthis.intro.length,\n\t\t);\n\t}\n\n\ttrimLines() {\n\t\treturn this.trim('[\\\\r\\\\n]');\n\t}\n\n\ttrim(charType) {\n\t\treturn this.trimStart(charType).trimEnd(charType);\n\t}\n\n\ttrimStart(charType) {\n\t\tconst rx = new RegExp('^' + (charType || '\\\\s') + '+');\n\t\tthis.intro = this.intro.replace(rx, '');\n\n\t\tif (!this.intro) {\n\t\t\tlet source;\n\t\t\tlet i = 0;\n\n\t\t\tdo {\n\t\t\t\tsource = this.sources[i++];\n\t\t\t\tif (!source) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t} while (!source.content.trimStartAborted(charType));\n\t\t}\n\n\t\treturn this;\n\t}\n\n\ttrimEnd(charType) {\n\t\tconst rx = new RegExp((charType || '\\\\s') + '+$');\n\n\t\tlet source;\n\t\tlet i = this.sources.length - 1;\n\n\t\tdo {\n\t\t\tsource = this.sources[i--];\n\t\t\tif (!source) {\n\t\t\t\tthis.intro = this.intro.replace(rx, '');\n\t\t\t\tbreak;\n\t\t\t}\n\t\t} while (!source.content.trimEndAborted(charType));\n\n\t\treturn this;\n\t}\n}\n","import MagicString from './MagicString.js';\nimport Bundle from './Bundle.js';\nimport SourceMap from './SourceMap.js';\n\nMagicString.Bundle = Bundle;\nMagicString.SourceMap = SourceMap;\nMagicString.default = MagicString; // work around TypeScript bug https://github.com/Rich-Harris/magic-string/pull/121\n\nexport default MagicString;\n"],"names":[],"mappings":"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","x_google_ignoreList":[2]} \ No newline at end of file diff --git a/frontend/node_modules/magic-string/package.json b/frontend/node_modules/magic-string/package.json new file mode 100644 index 0000000..5ba3ac6 --- /dev/null +++ b/frontend/node_modules/magic-string/package.json @@ -0,0 +1,67 @@ +{ + "name": "magic-string", + "version": "0.30.21", + "type": "commonjs", + "description": "Modify strings, generate sourcemaps", + "keywords": [ + "string", + "string manipulation", + "sourcemap", + "templating", + "transpilation" + ], + "repository": { + "type": "git", + "url": "git+https://github.com/Rich-Harris/magic-string.git" + }, + "license": "MIT", + "author": "Rich Harris", + "main": "./dist/magic-string.cjs.js", + "module": "./dist/magic-string.es.mjs", + "sideEffects": false, + "jsnext:main": "./dist/magic-string.es.mjs", + "types": "./dist/magic-string.cjs.d.ts", + "exports": { + "./package.json": "./package.json", + ".": { + "import": "./dist/magic-string.es.mjs", + "require": "./dist/magic-string.cjs.js" + } + }, + "files": [ + "dist/*", + "index.d.ts", + "README.md" + ], + "devDependencies": { + "@eslint/js": "^9.38.0", + "@rollup/plugin-node-resolve": "^16.0.3", + "@rollup/plugin-replace": "^6.0.2", + "benchmark": "^2.1.4", + "bumpp": "^10.3.1", + "conventional-changelog-cli": "^5.0.0", + "eslint": "^9.38.0", + "prettier": "^3.6.2", + "publint": "^0.3.15", + "rollup": "^4.52.5", + "source-map-js": "^1.2.1", + "source-map-support": "^0.5.21", + "vitest": "^4.0.2" + }, + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + }, + "scripts": { + "build": "rollup -c", + "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s", + "format": "prettier --single-quote --print-width 100 --use-tabs --write .", + "lint": "eslint src test && publint", + "lint:fix": "eslint src test --fix", + "release": "bumpp -x \"pnpm run changelog\" --all", + "pretest": "pnpm run build", + "test": "vitest run", + "test:dev": "vitest", + "bench": "pnpm run build && node benchmark/index.mjs", + "watch": "rollup -cw" + } +} \ No newline at end of file diff --git a/frontend/node_modules/marked/LICENSE b/frontend/node_modules/marked/LICENSE new file mode 100644 index 0000000..4bd2d4a --- /dev/null +++ b/frontend/node_modules/marked/LICENSE @@ -0,0 +1,44 @@ +# License information + +## Contribution License Agreement + +If you contribute code to this project, you are implicitly allowing your code +to be distributed under the MIT license. You are also implicitly verifying that +all code is your original work. `` + +## Marked + +Copyright (c) 2018+, MarkedJS (https://github.com/markedjs/) +Copyright (c) 2011-2018, Christopher Jeffrey (https://github.com/chjj/) + +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. + +## Markdown + +Copyright © 2004, John Gruber +http://daringfireball.net/ +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +* Neither the name “Markdown” nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +This software is provided by the copyright holders and contributors “as is” and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the copyright owner or contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage. diff --git a/frontend/node_modules/marked/README.md b/frontend/node_modules/marked/README.md new file mode 100644 index 0000000..8e343a4 --- /dev/null +++ b/frontend/node_modules/marked/README.md @@ -0,0 +1,115 @@ + + + + +# Marked + +[![npm](https://badgen.net/npm/v/marked)](https://www.npmjs.com/package/marked) +[![install size](https://badgen.net/packagephobia/install/marked)](https://packagephobia.now.sh/result?p=marked) +[![downloads](https://badgen.net/npm/dt/marked)](https://www.npmjs.com/package/marked) +[![github actions](https://github.com/markedjs/marked/workflows/Tests/badge.svg)](https://github.com/markedjs/marked/actions) +[![snyk](https://snyk.io/test/npm/marked/badge.svg)](https://snyk.io/test/npm/marked) + +- ⚡ built for speed +- ⬇️ low-level compiler for parsing markdown without caching or blocking for long periods of time +- ⚖️ light-weight while implementing all markdown features from the supported flavors & specifications +- 🌐 works in a browser, on a server, or from a command line interface (CLI) + +## Demo + +Check out the [demo page](https://marked.js.org/demo/) to see Marked in action ⛹️ + +## Docs + +Our [documentation pages](https://marked.js.org) are also rendered using marked 💯 + +Also read about: + +* [Options](https://marked.js.org/using_advanced) +* [Extensibility](https://marked.js.org/using_pro) + +## Compatibility + +**Node.js:** Only [current and LTS](https://nodejs.org/en/about/releases/) Node.js versions are supported. End of life Node.js versions may become incompatible with Marked at any point in time. + +**Browser:** [Baseline Widely Available](https://developer.mozilla.org/en-US/docs/Glossary/Baseline/Compatibility) + +## Installation + +**CLI:** + +```sh +npm install -g marked +``` + +**In-browser:** + +```sh +npm install marked +``` + +## Usage + +### Warning: 🚨 Marked does not [sanitize](https://marked.js.org/using_advanced#options) the output HTML. Please use a sanitize library, like [DOMPurify](https://github.com/cure53/DOMPurify) (recommended), [sanitize-html](https://github.com/apostrophecms/sanitize-html) or [insane](https://github.com/bevacqua/insane) on the *output* HTML! 🚨 + +``` +DOMPurify.sanitize(marked.parse(``)); +``` + +**CLI** + +``` bash +# Example with stdin input +$ marked -o hello.html +hello world +^D +$ cat hello.html +

    hello world

    +``` + +```bash +# Print all options +$ marked --help +``` + +**Node.js** + +```js +import { marked } from 'marked'; +const html = marked.parse('# Marked in Node.js'); +console.log(html); +``` + +**Browser** + +```html + + + + + Marked in the browser + + +
    + + + + +``` +or import esm module + +```html + +``` + +## License + +Copyright (c) 2018+, MarkedJS. (MIT License) +Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License) diff --git a/frontend/node_modules/marked/bin/main.js b/frontend/node_modules/marked/bin/main.js new file mode 100644 index 0000000..3c65857 --- /dev/null +++ b/frontend/node_modules/marked/bin/main.js @@ -0,0 +1,284 @@ +#!/usr/bin/env node + +/** + * Marked CLI + * Copyright (c) 2018+, MarkedJS. (MIT License) + * Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License) + */ + +import { promises } from 'node:fs'; +import { dirname, resolve } from 'node:path'; +import { homedir } from 'node:os'; +import { createRequire } from 'node:module'; +import { pathToFileURL } from 'node:url'; +import { marked } from '../lib/marked.esm.js'; + +const { access, readFile, writeFile } = promises; +const require = createRequire(import.meta.url); + +/** + * @param {Process} nodeProcess inject process so it can be mocked in tests. + */ +export async function main(nodeProcess) { + /** + * Man Page + */ + async function help() { + const { spawn } = await import('child_process'); + const { fileURLToPath } = await import('url'); + + const options = { + cwd: nodeProcess.cwd(), + env: nodeProcess.env, + stdio: 'inherit', + }; + + const __dirname = dirname(fileURLToPath(import.meta.url)); + const helpText = await readFile(resolve(__dirname, '../man/marked.1.md'), 'utf8'); + + await new Promise(res => { + const manProcess = spawn('man', [resolve(__dirname, '../man/marked.1')], options); + nodeProcess.on('SIGINT', () => { + manProcess.kill('SIGINT'); + }); + + manProcess.on('error', () => { + console.log(helpText); + }) + .on('close', res); + }); + } + + async function version() { + const pkg = require('../package.json'); + console.log(pkg.version); + } + + /** + * Main + */ + async function start(argv) { + const files = []; + const options = {}; + let input; + let output; + let string; + let arg; + let tokens; + let config; + let opt; + let noclobber; + + function getArg() { + let arg = argv.shift(); + + if (arg.indexOf('--') === 0) { + // e.g. --opt + arg = arg.split('='); + if (arg.length > 1) { + // e.g. --opt=val + argv.unshift(arg.slice(1).join('=')); + } + arg = arg[0]; + } else if (arg[0] === '-') { + if (arg.length > 2) { + // e.g. -abc + argv = arg.substring(1).split('').map(function(ch) { + return '-' + ch; + }).concat(argv); + arg = argv.shift(); + } else { + // e.g. -a + } + } else { + // e.g. foo + } + + return arg; + } + + while (argv.length) { + arg = getArg(); + switch (arg) { + case '-o': + case '--output': + output = argv.shift(); + break; + case '-i': + case '--input': + input = argv.shift(); + break; + case '-s': + case '--string': + string = argv.shift(); + break; + case '-t': + case '--tokens': + tokens = true; + break; + case '-c': + case '--config': + config = argv.shift(); + break; + case '-n': + case '--no-clobber': + noclobber = true; + break; + case '-h': + case '--help': + return await help(); + case '-v': + case '--version': + return await version(); + default: + if (arg.indexOf('--') === 0) { + opt = camelize(arg.replace(/^--(no-)?/, '')); + if (!(opt in marked.defaults)) { + continue; + } + if (arg.indexOf('--no-') === 0) { + options[opt] = typeof marked.defaults[opt] !== 'boolean' + ? null + : false; + } else { + options[opt] = typeof marked.defaults[opt] !== 'boolean' + ? argv.shift() + : true; + } + } else { + files.push(arg); + } + break; + } + } + + async function getData() { + if (string) { + return string; + } + if (input) { + return await readFile(input, 'utf8'); + } + if (files.length > 0) { + return await readFile(files.pop(), 'utf8'); + } + return await getStdin(); + } + + function resolveFile(file) { + return resolve(file.replace(/^~/, homedir)); + } + + function fileExists(file) { + return access(resolveFile(file)).then(() => true, () => false); + } + + async function runConfig(file) { + const configFile = resolveFile(file); + let markedConfig; + try { + // try require for json + markedConfig = require(configFile); + } catch(err) { + if (err.code !== 'ERR_REQUIRE_ESM') { + throw err; + } + // must import esm + markedConfig = await import(pathToFileURL(configFile).href); + } + + if (markedConfig.default) { + markedConfig = markedConfig.default; + } + + if (typeof markedConfig === 'function') { + markedConfig(marked); + } else { + marked.use(markedConfig); + } + } + + const data = await getData(); + + if (config) { + if (!await fileExists(config)) { + throw Error(`Cannot load config file '${config}'`); + } + + await runConfig(config); + } else { + const defaultConfig = [ + '~/.marked.json', + '~/.marked.js', + '~/.marked/index.js', + ]; + + for (const configFile of defaultConfig) { + if (await fileExists(configFile)) { + await runConfig(configFile); + break; + } + } + } + + const html = tokens + ? JSON.stringify(marked.lexer(data, options), null, 2) + : await marked.parse(data, options); + + if (output) { + if (noclobber && await fileExists(output)) { + throw Error('marked: output file \'' + output + '\' already exists, disable the \'-n\' / \'--no-clobber\' flag to overwrite\n'); + } + return await writeFile(output, html); + } + + nodeProcess.stdout.write(html + '\n'); + } + + /** + * Helpers + */ + function getStdin() { + return new Promise((resolve, reject) => { + const stdin = nodeProcess.stdin; + let buff = ''; + + stdin.setEncoding('utf8'); + + stdin.on('data', function(data) { + buff += data; + }); + + stdin.on('error', function(err) { + reject(err); + }); + + stdin.on('end', function() { + resolve(buff); + }); + + stdin.resume(); + }); + } + + /** + * @param {string} text + */ + function camelize(text) { + return text.replace(/(\w)-(\w)/g, function(_, a, b) { + return a + b.toUpperCase(); + }); + } + + try { + await start(nodeProcess.argv.slice(2)); + nodeProcess.exit(0); + } catch(err) { + if (err.code === 'ENOENT') { + nodeProcess.stderr.write('marked: ' + err.path + ': No such file or directory'); + } else { + nodeProcess.stderr.write(err.message); + } + return nodeProcess.exit(1); + } +} diff --git a/frontend/node_modules/marked/bin/marked.js b/frontend/node_modules/marked/bin/marked.js new file mode 100755 index 0000000..65ff0aa --- /dev/null +++ b/frontend/node_modules/marked/bin/marked.js @@ -0,0 +1,16 @@ +#!/usr/bin/env node + +/** + * Marked CLI + * Copyright (c) 2018+, MarkedJS. (MIT License) + * Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License) + */ + +import { main } from './main.js'; + +/** + * Expose / Entry Point + */ + +process.title = 'marked'; +main(process); diff --git a/frontend/node_modules/marked/lib/marked.d.ts b/frontend/node_modules/marked/lib/marked.d.ts new file mode 100644 index 0000000..05d1fda --- /dev/null +++ b/frontend/node_modules/marked/lib/marked.d.ts @@ -0,0 +1,760 @@ +// Generated by dts-bundle-generator v9.5.1 + +export type MarkedToken = (Tokens.Blockquote | Tokens.Br | Tokens.Checkbox | Tokens.Code | Tokens.Codespan | Tokens.Def | Tokens.Del | Tokens.Em | Tokens.Escape | Tokens.Heading | Tokens.Hr | Tokens.HTML | Tokens.Image | Tokens.Link | Tokens.List | Tokens.ListItem | Tokens.Paragraph | Tokens.Space | Tokens.Strong | Tokens.Table | Tokens.Tag | Tokens.Text); +export type Token = (MarkedToken | Tokens.Generic); +export declare namespace Tokens { + interface Blockquote { + type: "blockquote"; + raw: string; + text: string; + tokens: Token[]; + } + interface Br { + type: "br"; + raw: string; + } + interface Checkbox { + type: "checkbox"; + raw: string; + checked: boolean; + } + interface Code { + type: "code"; + raw: string; + codeBlockStyle?: "indented"; + lang?: string; + text: string; + escaped?: boolean; + } + interface Codespan { + type: "codespan"; + raw: string; + text: string; + } + interface Def { + type: "def"; + raw: string; + tag: string; + href: string; + title: string; + } + interface Del { + type: "del"; + raw: string; + text: string; + tokens: Token[]; + } + interface Em { + type: "em"; + raw: string; + text: string; + tokens: Token[]; + } + interface Escape { + type: "escape"; + raw: string; + text: string; + } + interface Generic { + [index: string]: any; + type: string; + raw: string; + tokens?: Token[]; + } + interface Heading { + type: "heading"; + raw: string; + depth: number; + text: string; + tokens: Token[]; + } + interface Hr { + type: "hr"; + raw: string; + } + interface HTML { + type: "html"; + raw: string; + pre: boolean; + text: string; + block: boolean; + } + interface Image { + type: "image"; + raw: string; + href: string; + title: string | null; + text: string; + tokens: Token[]; + } + interface Link { + type: "link"; + raw: string; + href: string; + title?: string | null; + text: string; + tokens: Token[]; + } + interface List { + type: "list"; + raw: string; + ordered: boolean; + start: number | ""; + loose: boolean; + items: ListItem[]; + } + interface ListItem { + type: "list_item"; + raw: string; + task: boolean; + checked?: boolean; + loose: boolean; + text: string; + tokens: Token[]; + } + interface Paragraph { + type: "paragraph"; + raw: string; + pre?: boolean; + text: string; + tokens: Token[]; + } + interface Space { + type: "space"; + raw: string; + } + interface Strong { + type: "strong"; + raw: string; + text: string; + tokens: Token[]; + } + interface Table { + type: "table"; + raw: string; + align: Array<"center" | "left" | "right" | null>; + header: TableCell[]; + rows: TableCell[][]; + } + interface TableCell { + text: string; + tokens: Token[]; + header: boolean; + align: "center" | "left" | "right" | null; + } + interface TableRow

    { + text: P; + } + interface Tag { + type: "html"; + raw: string; + inLink: boolean; + inRawBlock: boolean; + text: string; + block: boolean; + } + interface Text { + type: "text"; + raw: string; + text: string; + tokens?: Token[]; + escaped?: boolean; + } +} +export type Links = Record>; +export type TokensList = Token[] & { + links: Links; +}; +/** + * Renderer + */ +declare class _Renderer { + options: MarkedOptions; + parser: _Parser; + constructor(options?: MarkedOptions); + space(token: Tokens.Space): RendererOutput; + code({ text, lang, escaped }: Tokens.Code): RendererOutput; + blockquote({ tokens }: Tokens.Blockquote): RendererOutput; + html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput; + def(token: Tokens.Def): RendererOutput; + heading({ tokens, depth }: Tokens.Heading): RendererOutput; + hr(token: Tokens.Hr): RendererOutput; + list(token: Tokens.List): RendererOutput; + listitem(item: Tokens.ListItem): RendererOutput; + checkbox({ checked }: Tokens.Checkbox): RendererOutput; + paragraph({ tokens }: Tokens.Paragraph): RendererOutput; + table(token: Tokens.Table): RendererOutput; + tablerow({ text }: Tokens.TableRow): RendererOutput; + tablecell(token: Tokens.TableCell): RendererOutput; + /** + * span level renderer + */ + strong({ tokens }: Tokens.Strong): RendererOutput; + em({ tokens }: Tokens.Em): RendererOutput; + codespan({ text }: Tokens.Codespan): RendererOutput; + br(token: Tokens.Br): RendererOutput; + del({ tokens }: Tokens.Del): RendererOutput; + link({ href, title, tokens }: Tokens.Link): RendererOutput; + image({ href, title, text, tokens }: Tokens.Image): RendererOutput; + text(token: Tokens.Text | Tokens.Escape): RendererOutput; +} +/** + * TextRenderer + * returns only the textual part of the token + */ +declare class _TextRenderer { + strong({ text }: Tokens.Strong): RendererOutput; + em({ text }: Tokens.Em): RendererOutput; + codespan({ text }: Tokens.Codespan): RendererOutput; + del({ text }: Tokens.Del): RendererOutput; + html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput; + text({ text }: Tokens.Text | Tokens.Escape | Tokens.Tag): RendererOutput; + link({ text }: Tokens.Link): RendererOutput; + image({ text }: Tokens.Image): RendererOutput; + br(): RendererOutput; + checkbox({ raw }: Tokens.Checkbox): RendererOutput; +} +/** + * Parsing & Compiling + */ +declare class _Parser { + options: MarkedOptions; + renderer: _Renderer; + textRenderer: _TextRenderer; + constructor(options?: MarkedOptions); + /** + * Static Parse Method + */ + static parse(tokens: Token[], options?: MarkedOptions): ParserOutput; + /** + * Static Parse Inline Method + */ + static parseInline(tokens: Token[], options?: MarkedOptions): ParserOutput; + /** + * Parse Loop + */ + parse(tokens: Token[]): ParserOutput; + /** + * Parse Inline Tokens + */ + parseInline(tokens: Token[], renderer?: _Renderer | _TextRenderer): ParserOutput; +} +declare const other: { + codeRemoveIndent: RegExp; + outputLinkReplace: RegExp; + indentCodeCompensation: RegExp; + beginningSpace: RegExp; + endingHash: RegExp; + startingSpaceChar: RegExp; + endingSpaceChar: RegExp; + nonSpaceChar: RegExp; + newLineCharGlobal: RegExp; + tabCharGlobal: RegExp; + multipleSpaceGlobal: RegExp; + blankLine: RegExp; + doubleBlankLine: RegExp; + blockquoteStart: RegExp; + blockquoteSetextReplace: RegExp; + blockquoteSetextReplace2: RegExp; + listReplaceNesting: RegExp; + listIsTask: RegExp; + listReplaceTask: RegExp; + listTaskCheckbox: RegExp; + anyLine: RegExp; + hrefBrackets: RegExp; + tableDelimiter: RegExp; + tableAlignChars: RegExp; + tableRowBlankLine: RegExp; + tableAlignRight: RegExp; + tableAlignCenter: RegExp; + tableAlignLeft: RegExp; + startATag: RegExp; + endATag: RegExp; + startPreScriptTag: RegExp; + endPreScriptTag: RegExp; + startAngleBracket: RegExp; + endAngleBracket: RegExp; + pedanticHrefTitle: RegExp; + unicodeAlphaNumeric: RegExp; + escapeTest: RegExp; + escapeReplace: RegExp; + escapeTestNoEncode: RegExp; + escapeReplaceNoEncode: RegExp; + caret: RegExp; + percentDecode: RegExp; + findPipe: RegExp; + splitPipe: RegExp; + slashPipe: RegExp; + carriageReturn: RegExp; + spaceLine: RegExp; + notSpaceStart: RegExp; + endingNewline: RegExp; + listItemRegex: (bull: string) => RegExp; + nextBulletRegex: (indent: number) => RegExp; + hrRegex: (indent: number) => RegExp; + fencesBeginRegex: (indent: number) => RegExp; + headingBeginRegex: (indent: number) => RegExp; + htmlBeginRegex: (indent: number) => RegExp; + blockquoteBeginRegex: (indent: number) => RegExp; +}; +declare const blockNormal: { + blockquote: RegExp; + code: RegExp; + def: RegExp; + fences: RegExp; + heading: RegExp; + hr: RegExp; + html: RegExp; + lheading: RegExp; + list: RegExp; + newline: RegExp; + paragraph: RegExp; + table: RegExp; + text: RegExp; +}; +export type BlockKeys = keyof typeof blockNormal; +declare const inlineNormal: { + _backpedal: RegExp; + anyPunctuation: RegExp; + autolink: RegExp; + blockSkip: RegExp; + br: RegExp; + code: RegExp; + del: RegExp; + delLDelim: RegExp; + delRDelim: RegExp; + emStrongLDelim: RegExp; + emStrongRDelimAst: RegExp; + emStrongRDelimUnd: RegExp; + escape: RegExp; + link: RegExp; + nolink: RegExp; + punctuation: RegExp; + reflink: RegExp; + reflinkSearch: RegExp; + tag: RegExp; + text: RegExp; + url: RegExp; +}; +export type InlineKeys = keyof typeof inlineNormal; +export interface Rules { + other: typeof other; + block: Record; + inline: Record; +} +/** + * Tokenizer + */ +declare class _Tokenizer { + options: MarkedOptions; + rules: Rules; + lexer: _Lexer; + constructor(options?: MarkedOptions); + space(src: string): Tokens.Space | undefined; + code(src: string): Tokens.Code | undefined; + fences(src: string): Tokens.Code | undefined; + heading(src: string): Tokens.Heading | undefined; + hr(src: string): Tokens.Hr | undefined; + blockquote(src: string): Tokens.Blockquote | undefined; + list(src: string): Tokens.List | undefined; + html(src: string): Tokens.HTML | undefined; + def(src: string): Tokens.Def | undefined; + table(src: string): Tokens.Table | undefined; + lheading(src: string): Tokens.Heading | undefined; + paragraph(src: string): Tokens.Paragraph | undefined; + text(src: string): Tokens.Text | undefined; + escape(src: string): Tokens.Escape | undefined; + tag(src: string): Tokens.Tag | undefined; + link(src: string): Tokens.Link | Tokens.Image | undefined; + reflink(src: string, links: Links): Tokens.Link | Tokens.Image | Tokens.Text | undefined; + emStrong(src: string, maskedSrc: string, prevChar?: string): Tokens.Em | Tokens.Strong | undefined; + codespan(src: string): Tokens.Codespan | undefined; + br(src: string): Tokens.Br | undefined; + del(src: string, maskedSrc: string, prevChar?: string): Tokens.Del | undefined; + autolink(src: string): Tokens.Link | undefined; + url(src: string): Tokens.Link | undefined; + inlineText(src: string): Tokens.Text | undefined; +} +declare class _Hooks { + options: MarkedOptions; + block?: boolean; + constructor(options?: MarkedOptions); + static passThroughHooks: Set; + static passThroughHooksRespectAsync: Set; + /** + * Process markdown before marked + */ + preprocess(markdown: string): string; + /** + * Process HTML after marked is finished + */ + postprocess(html: ParserOutput): ParserOutput; + /** + * Process all tokens before walk tokens + */ + processAllTokens(tokens: Token[] | TokensList): Token[] | TokensList; + /** + * Mask contents that should not be interpreted as em/strong delimiters + */ + emStrongMask(src: string): string; + /** + * Provide function to tokenize markdown + */ + provideLexer(block?: boolean | undefined): typeof _Lexer.lexInline; + /** + * Provide function to parse tokens + */ + provideParser(block?: boolean | undefined): (tokens: Token[], options?: MarkedOptions | undefined) => ParserOutput; +} +export interface TokenizerThis { + lexer: _Lexer; +} +export type TokenizerExtensionFunction = (this: TokenizerThis, src: string, tokens: Token[] | TokensList) => Tokens.Generic | undefined; +export type TokenizerStartFunction = (this: TokenizerThis, src: string) => number | void; +export interface TokenizerExtension { + name: string; + level: "block" | "inline"; + start?: TokenizerStartFunction; + tokenizer: TokenizerExtensionFunction; + childTokens?: string[]; +} +export interface RendererThis { + parser: _Parser; +} +export type RendererExtensionFunction = (this: RendererThis, token: Tokens.Generic) => RendererOutput | false | undefined; +export interface RendererExtension { + name: string; + renderer: RendererExtensionFunction; +} +export type TokenizerAndRendererExtension = TokenizerExtension | RendererExtension | (TokenizerExtension & RendererExtension); +export type HooksApi = Omit<_Hooks, "constructor" | "options" | "block">; +export type HooksObject = { + [K in keyof HooksApi]?: (this: _Hooks, ...args: Parameters[K]>) => ReturnType[K]> | Promise[K]>>; +}; +export type RendererApi = Omit<_Renderer, "constructor" | "options" | "parser">; +export type RendererObject = { + [K in keyof RendererApi]?: (this: _Renderer, ...args: Parameters[K]>) => ReturnType[K]> | false; +}; +export type TokenizerApi = Omit<_Tokenizer, "constructor" | "options" | "rules" | "lexer">; +export type TokenizerObject = { + [K in keyof TokenizerApi]?: (this: _Tokenizer, ...args: Parameters[K]>) => ReturnType[K]> | false; +}; +export interface MarkedExtension { + /** + * True will tell marked to await any walkTokens functions before parsing the tokens and returning an HTML string. + */ + async?: boolean; + /** + * Enable GFM line breaks. This option requires the gfm option to be true. + */ + breaks?: boolean; + /** + * Add tokenizers and renderers to marked + */ + extensions?: TokenizerAndRendererExtension[] | null; + /** + * Enable GitHub flavored markdown. + */ + gfm?: boolean; + /** + * Hooks are methods that hook into some part of marked. + * preprocess is called to process markdown before sending it to marked. + * processAllTokens is called with the TokensList before walkTokens. + * postprocess is called to process html after marked has finished parsing. + * emStrongMask is called to mask contents that should not be interpreted as em/strong delimiters. + * provideLexer is called to provide a function to tokenize markdown. + * provideParser is called to provide a function to parse tokens. + */ + hooks?: HooksObject | null; + /** + * Conform to obscure parts of markdown.pl as much as possible. Don't fix any of the original markdown bugs or poor behavior. + */ + pedantic?: boolean; + /** + * Type: object Default: new Renderer() + * + * An object containing functions to render tokens to HTML. + */ + renderer?: RendererObject | null; + /** + * Shows an HTML error message when rendering fails. + */ + silent?: boolean; + /** + * The tokenizer defines how to turn markdown text into tokens. + */ + tokenizer?: TokenizerObject | null; + /** + * The walkTokens function gets called with every token. + * Child tokens are called before moving on to sibling tokens. + * Each token is passed by reference so updates are persisted when passed to the parser. + * The return value of the function is ignored. + */ + walkTokens?: ((token: Token) => void | Promise) | null; +} +export interface MarkedOptions extends Omit, "hooks" | "renderer" | "tokenizer" | "extensions" | "walkTokens"> { + /** + * Hooks are methods that hook into some part of marked. + */ + hooks?: _Hooks | null; + /** + * Type: object Default: new Renderer() + * + * An object containing functions to render tokens to HTML. + */ + renderer?: _Renderer | null; + /** + * The tokenizer defines how to turn markdown text into tokens. + */ + tokenizer?: _Tokenizer | null; + /** + * Custom extensions + */ + extensions?: null | { + renderers: { + [name: string]: RendererExtensionFunction; + }; + childTokens: { + [name: string]: string[]; + }; + inline?: TokenizerExtensionFunction[]; + block?: TokenizerExtensionFunction[]; + startInline?: TokenizerStartFunction[]; + startBlock?: TokenizerStartFunction[]; + }; + /** + * walkTokens function returns array of values for Promise.all + */ + walkTokens?: null | ((token: Token) => void | Promise | (void | Promise)[]); +} +/** + * Block Lexer + */ +declare class _Lexer { + tokens: TokensList; + options: MarkedOptions; + state: { + inLink: boolean; + inRawBlock: boolean; + top: boolean; + }; + inlineQueue: { + src: string; + tokens: Token[]; + }[]; + private tokenizer; + constructor(options?: MarkedOptions); + /** + * Expose Rules + */ + static get rules(): { + block: { + normal: { + blockquote: RegExp; + code: RegExp; + def: RegExp; + fences: RegExp; + heading: RegExp; + hr: RegExp; + html: RegExp; + lheading: RegExp; + list: RegExp; + newline: RegExp; + paragraph: RegExp; + table: RegExp; + text: RegExp; + }; + gfm: Record<"code" | "blockquote" | "hr" | "html" | "table" | "text" | "def" | "heading" | "list" | "paragraph" | "fences" | "lheading" | "newline", RegExp>; + pedantic: Record<"code" | "blockquote" | "hr" | "html" | "table" | "text" | "def" | "heading" | "list" | "paragraph" | "fences" | "lheading" | "newline", RegExp>; + }; + inline: { + normal: { + _backpedal: RegExp; + anyPunctuation: RegExp; + autolink: RegExp; + blockSkip: RegExp; + br: RegExp; + code: RegExp; + del: RegExp; + delLDelim: RegExp; + delRDelim: RegExp; + emStrongLDelim: RegExp; + emStrongRDelimAst: RegExp; + emStrongRDelimUnd: RegExp; + escape: RegExp; + link: RegExp; + nolink: RegExp; + punctuation: RegExp; + reflink: RegExp; + reflinkSearch: RegExp; + tag: RegExp; + text: RegExp; + url: RegExp; + }; + gfm: Record<"link" | "code" | "url" | "br" | "del" | "text" | "tag" | "escape" | "reflink" | "nolink" | "_backpedal" | "anyPunctuation" | "autolink" | "blockSkip" | "delLDelim" | "delRDelim" | "emStrongLDelim" | "emStrongRDelimAst" | "emStrongRDelimUnd" | "punctuation" | "reflinkSearch", RegExp>; + breaks: Record<"link" | "code" | "url" | "br" | "del" | "text" | "tag" | "escape" | "reflink" | "nolink" | "_backpedal" | "anyPunctuation" | "autolink" | "blockSkip" | "delLDelim" | "delRDelim" | "emStrongLDelim" | "emStrongRDelimAst" | "emStrongRDelimUnd" | "punctuation" | "reflinkSearch", RegExp>; + pedantic: Record<"link" | "code" | "url" | "br" | "del" | "text" | "tag" | "escape" | "reflink" | "nolink" | "_backpedal" | "anyPunctuation" | "autolink" | "blockSkip" | "delLDelim" | "delRDelim" | "emStrongLDelim" | "emStrongRDelimAst" | "emStrongRDelimUnd" | "punctuation" | "reflinkSearch", RegExp>; + }; + }; + /** + * Static Lex Method + */ + static lex(src: string, options?: MarkedOptions): TokensList; + /** + * Static Lex Inline Method + */ + static lexInline(src: string, options?: MarkedOptions): Token[]; + /** + * Preprocessing + */ + lex(src: string): TokensList; + /** + * Lexing + */ + blockTokens(src: string, tokens?: Token[], lastParagraphClipped?: boolean): Token[]; + blockTokens(src: string, tokens?: TokensList, lastParagraphClipped?: boolean): TokensList; + inline(src: string, tokens?: Token[]): Token[]; + /** + * Lexing/Compiling + */ + inlineTokens(src: string, tokens?: Token[]): Token[]; + private infiniteLoopError; +} +/** + * Gets the original marked default options. + */ +declare function _getDefaults(): MarkedOptions; +declare let _defaults: MarkedOptions; +export type MaybePromise = void | Promise; +export declare class Marked { + defaults: MarkedOptions; + options: (opt: MarkedOptions) => this; + parse: { + (src: string, options: MarkedOptions & { + async: true; + }): Promise; + (src: string, options: MarkedOptions & { + async: false; + }): ParserOutput; + (src: string, options?: MarkedOptions | null): ParserOutput | Promise; + }; + parseInline: { + (src: string, options: MarkedOptions & { + async: true; + }): Promise; + (src: string, options: MarkedOptions & { + async: false; + }): ParserOutput; + (src: string, options?: MarkedOptions | null): ParserOutput | Promise; + }; + Parser: { + new (options?: MarkedOptions | undefined): _Parser; + parse(tokens: Token[], options?: MarkedOptions): ParserOutput_1; + parseInline(tokens: Token[], options?: MarkedOptions): ParserOutput_1; + }; + Renderer: { + new (options?: MarkedOptions | undefined): _Renderer; + }; + TextRenderer: { + new (): _TextRenderer; + }; + Lexer: typeof _Lexer; + Tokenizer: { + new (options?: MarkedOptions | undefined): _Tokenizer; + }; + Hooks: { + new (options?: MarkedOptions | undefined): _Hooks; + passThroughHooks: Set; + passThroughHooksRespectAsync: Set; + }; + constructor(...args: MarkedExtension[]); + /** + * Run callback for every token + */ + walkTokens(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]): MaybePromise[]; + use(...args: MarkedExtension[]): this; + setOptions(opt: MarkedOptions): this; + lexer(src: string, options?: MarkedOptions): TokensList; + parser(tokens: Token[], options?: MarkedOptions): ParserOutput; + private parseMarkdown; + private onError; +} +/** + * Compiles markdown to HTML asynchronously. + * + * @param src String of markdown source to be compiled + * @param options Hash of options, having async: true + * @return Promise of string of compiled HTML + */ +export declare function marked(src: string, options: MarkedOptions & { + async: true; +}): Promise; +/** + * Compiles markdown to HTML. + * + * @param src String of markdown source to be compiled + * @param options Optional hash of options + * @return String of compiled HTML. Will be a Promise of string if async is set to true by any extensions. + */ +export declare function marked(src: string, options: MarkedOptions & { + async: false; +}): string; +export declare function marked(src: string, options: MarkedOptions & { + async: true; +}): Promise; +export declare function marked(src: string, options?: MarkedOptions | null): string | Promise; +export declare namespace marked { + var options: (options: MarkedOptions) => typeof marked; + var setOptions: (options: MarkedOptions) => typeof marked; + var getDefaults: typeof _getDefaults; + var defaults: MarkedOptions; + var use: (...args: MarkedExtension[]) => typeof marked; + var walkTokens: (tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) => MaybePromise[]; + var parseInline: { + (src: string, options: MarkedOptions & { + async: true; + }): Promise; + (src: string, options: MarkedOptions & { + async: false; + }): string; + (src: string, options?: MarkedOptions | null | undefined): string | Promise; + }; + var Parser: typeof _Parser; + var parser: typeof _Parser.parse; + var Renderer: typeof _Renderer; + var TextRenderer: typeof _TextRenderer; + var Lexer: typeof _Lexer; + var lexer: typeof _Lexer.lex; + var Tokenizer: typeof _Tokenizer; + var Hooks: typeof _Hooks; + var parse: typeof marked; +} +export declare const options: (options: MarkedOptions) => typeof marked; +export declare const setOptions: (options: MarkedOptions) => typeof marked; +export declare const use: (...args: MarkedExtension[]) => typeof marked; +export declare const walkTokens: (tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) => MaybePromise[]; +export declare const parseInline: { + (src: string, options: MarkedOptions & { + async: true; + }): Promise; + (src: string, options: MarkedOptions & { + async: false; + }): string; + (src: string, options?: MarkedOptions | null | undefined): string | Promise; +}; +export declare const parse: typeof marked; +export declare const parser: typeof _Parser.parse; +export declare const lexer: typeof _Lexer.lex; + +export { + _Hooks as Hooks, + _Lexer as Lexer, + _Parser as Parser, + _Renderer as Renderer, + _TextRenderer as TextRenderer, + _Tokenizer as Tokenizer, + _defaults as defaults, + _getDefaults as getDefaults, +}; + +export {}; diff --git a/frontend/node_modules/marked/lib/marked.esm.js b/frontend/node_modules/marked/lib/marked.esm.js new file mode 100644 index 0000000..92fbef0 --- /dev/null +++ b/frontend/node_modules/marked/lib/marked.esm.js @@ -0,0 +1,77 @@ +/** + * marked v18.0.5 - a markdown parser + * Copyright (c) 2018-2026, MarkedJS. (MIT License) + * Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License) + * https://github.com/markedjs/marked + */ + +/** + * DO NOT EDIT THIS FILE + * The code in this file is generated from files in ./src/ + */ + +function M(){return{async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null}}var T=M();function N(l){T=l}var _={exec:()=>null};function E(l){let e=[];return t=>{let n=Math.max(0,Math.min(3,t-1)),s=e[n];return s||(s=l(n),e[n]=s),s}}function d(l,e=""){let t=typeof l=="string"?l:l.source,n={replace:(s,r)=>{let i=typeof r=="string"?r:r.source;return i=i.replace(m.caret,"$1"),t=t.replace(s,i),n},getRegex:()=>new RegExp(t,e)};return n}var Te=((l="")=>{try{return!!new RegExp("(?<=1)(?/,blockquoteSetextReplace:/\n {0,3}((?:=+|-+) *)(?=\n|$)/g,blockquoteSetextReplace2:/^ {0,3}>[ \t]?/gm,listReplaceNesting:/^ {1,4}(?=( {4})*[^ ])/g,listIsTask:/^\[[ xX]\] +\S/,listReplaceTask:/^\[[ xX]\] +/,listTaskCheckbox:/\[[ 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,caret:/(^|[^\[])\^/g,percentDecode:/%25/g,findPipe:/\|/g,splitPipe:/ \|/,slashPipe:/\\\|/g,carriageReturn:/\r\n|\r/g,spaceLine:/^ +$/gm,notSpaceStart:/^\S*/,endingNewline:/\n$/,listItemRegex:l=>new RegExp(`^( {0,3}${l})((?:[ ][^\\n]*)?(?:\\n|$))`),nextBulletRegex:E(l=>new RegExp(`^ {0,${l}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`)),hrRegex:E(l=>new RegExp(`^ {0,${l}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`)),fencesBeginRegex:E(l=>new RegExp(`^ {0,${l}}(?:\`\`\`|~~~)`)),headingBeginRegex:E(l=>new RegExp(`^ {0,${l}}#`)),htmlBeginRegex:E(l=>new RegExp(`^ {0,${l}}<(?:[a-z].*>|!--)`,"i")),blockquoteBeginRegex:E(l=>new RegExp(`^ {0,${l}}>`))},Oe=/^(?:[ \t]*(?:\n|$))+/,we=/^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/,ye=/^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,B=/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,Pe=/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,j=/ {0,3}(?:[*+-]|\d{1,9}[.)])/,oe=/^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,ae=d(oe).replace(/bull/g,j).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(),Se=d(oe).replace(/bull/g,j).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(),F=/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,$e=/^[^\n]+/,U=/(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/,Le=d(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label",U).replace("title",/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(),_e=d(/^(bull)([ \t][^\n]*?)?(?:\n|$)/).replace(/bull/g,j).getRegex(),H="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",K=/|$))/,ze=d("^ {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",K).replace("tag",H).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),le=d(F).replace("hr",B).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[.)])[ \\t]+[^ \\t\\n]").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",H).getRegex(),Me=d(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph",le).getRegex(),W={blockquote:Me,code:we,def:Le,fences:ye,heading:Pe,hr:B,html:ze,lheading:ae,list:_e,newline:Oe,paragraph:le,table:_,text:$e},se=d("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr",B).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[.)])[ \\t]").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",H).getRegex(),Ee={...W,lheading:Se,table:se,paragraph:d(F).replace("hr",B).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("table",se).replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",H).getRegex()},Ie={...W,html:d(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment",K).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:_,lheading:/^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,paragraph:d(F).replace("hr",B).replace("heading",` *#{1,6} *[^ +]`).replace("lheading",ae).replace("|table","").replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").replace("|tag","").getRegex()},Ae=/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,Ce=/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,ue=/^( {2,}|\\)\n(?!\s*$)/,Be=/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\`+)[^`]+\k(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-",Te?"(?`+)[^`]+\k(?!`)/).replace("html",/<(?! )[^<>]*?>/).getRegex(),ce=/^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/,Ze=d(ce,"u").replace(/punct/g,I).getRegex(),Ge=d(ce,"u").replace(/punct/g,pe).getRegex(),he="^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)",Ne=d(he,"gu").replace(/notPunctSpace/g,X).replace(/punctSpace/g,Z).replace(/punct/g,I).getRegex(),Qe=d(he,"gu").replace(/notPunctSpace/g,ve).replace(/punctSpace/g,qe).replace(/punct/g,pe).getRegex(),je=d("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)","gu").replace(/notPunctSpace/g,X).replace(/punctSpace/g,Z).replace(/punct/g,I).getRegex(),Fe=d(/^~~?(?:((?!~)punct)|[^\s~])/,"u").replace(/punct/g,I).getRegex(),Ue="^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)",Ke=d(Ue,"gu").replace(/notPunctSpace/g,X).replace(/punctSpace/g,Z).replace(/punct/g,I).getRegex(),We=d(/\\(punct)/,"gu").replace(/punct/g,I).getRegex(),Xe=d(/^<(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(),Je=d(K).replace("(?:-->|$)","-->").getRegex(),Ve=d("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment",Je).replace("attribute",/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(),v=/(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/,Ye=d(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label",v).replace("href",/<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title",/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(),ke=d(/^!?\[(label)\]\[(ref)\]/).replace("label",v).replace("ref",U).getRegex(),de=d(/^!?\[(ref)\](?:\[\])?/).replace("ref",U).getRegex(),et=d("reflink|nolink(?!\\()","g").replace("reflink",ke).replace("nolink",de).getRegex(),ie=/[hH][tT][tT][pP][sS]?|[fF][tT][pP]/,J={_backpedal:_,anyPunctuation:We,autolink:Xe,blockSkip:He,br:ue,code:Ce,del:_,delLDelim:_,delRDelim:_,emStrongLDelim:Ze,emStrongRDelimAst:Ne,emStrongRDelimUnd:je,escape:Ae,link:Ye,nolink:de,punctuation:De,reflink:ke,reflinkSearch:et,tag:Ve,text:Be,url:_},tt={...J,link:d(/^!?\[(label)\]\((.*?)\)/).replace("label",v).getRegex(),reflink:d(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",v).getRegex()},Q={...J,emStrongRDelimAst:Qe,emStrongLDelim:Ge,delLDelim:Fe,delRDelim:Ke,url:d(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol",ie).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\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/,text:d(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\":">",'"':""","'":"'"},ge=l=>rt[l];function O(l,e){if(e){if(m.escapeTest.test(l))return l.replace(m.escapeReplace,ge)}else if(m.escapeTestNoEncode.test(l))return l.replace(m.escapeReplaceNoEncode,ge);return l}function V(l){try{l=encodeURI(l).replace(m.percentDecode,"%")}catch{return null}return l}function Y(l,e){let t=l.replace(m.findPipe,(r,i,o)=>{let u=!1,a=i;for(;--a>=0&&o[a]==="\\";)u=!u;return u?"|":" |"}),n=t.split(m.splitPipe),s=0;if(n[0].trim()||n.shift(),n.length>0&&!n.at(-1)?.trim()&&n.pop(),e)if(n.length>e)n.splice(e);else for(;n.length=0&&m.blankLine.test(e[t]);)t--;return e.length-t<=2?l:e.slice(0,t+1).join(` +`)}function fe(l,e){if(l.indexOf(e[1])===-1)return-1;let t=0;for(let n=0;n0?-2:-1}function me(l,e=0){let t=e,n="";for(let s of l)if(s===" "){let r=4-t%4;n+=" ".repeat(r),t+=r}else n+=s,t++;return n}function xe(l,e,t,n,s){let r=e.href,i=e.title||null,o=l[1].replace(s.other.outputLinkReplace,"$1");n.state.inLink=!0;let u={type:l[0].charAt(0)==="!"?"image":"link",raw:t,href:r,title:i,text:o,tokens:n.inlineTokens(o)};return n.state.inLink=!1,u}function st(l,e,t){let n=l.match(t.other.indentCodeCompensation);if(n===null)return e;let s=n[1];return e.split(` +`).map(r=>{let i=r.match(t.other.beginningSpace);if(i===null)return r;let[o]=i;return o.length>=s.length?r.slice(s.length):r}).join(` +`)}var w=class{options;rules;lexer;constructor(e){this.options=e||T}space(e){let t=this.rules.block.newline.exec(e);if(t&&t[0].length>0)return{type:"space",raw:t[0]}}code(e){let t=this.rules.block.code.exec(e);if(t){let n=this.options.pedantic?t[0]:ee(t[0]),s=n.replace(this.rules.other.codeRemoveIndent,"");return{type:"code",raw:n,codeBlockStyle:"indented",text:s}}}fences(e){let t=this.rules.block.fences.exec(e);if(t){let n=t[0],s=st(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:s}}}heading(e){let t=this.rules.block.heading.exec(e);if(t){let n=t[2].trim();if(this.rules.other.endingHash.test(n)){let s=$(n,"#");(this.options.pedantic||!s||this.rules.other.endingSpaceChar.test(s))&&(n=s.trim())}return{type:"heading",raw:$(t[0],` +`),depth:t[1].length,text:n,tokens:this.lexer.inline(n)}}}hr(e){let t=this.rules.block.hr.exec(e);if(t)return{type:"hr",raw:$(t[0],` +`)}}blockquote(e){let t=this.rules.block.blockquote.exec(e);if(t){let n=$(t[0],` +`).split(` +`),s="",r="",i=[];for(;n.length>0;){let o=!1,u=[],a;for(a=0;a1,r={type:"list",raw:"",ordered:s,start:s?+n.slice(0,-1):"",loose:!1,items:[]};n=s?`\\d{1,9}\\${n.slice(-1)}`:`\\${n}`,this.options.pedantic&&(n=s?n:"[*+-]");let i=this.rules.other.listItemRegex(n),o=!1;for(;e;){let a=!1,c="",p="";if(!(t=i.exec(e))||this.rules.block.hr.test(e))break;c=t[0],e=e.substring(c.length);let k=me(t[2].split(` +`,1)[0],t[1].length),h=e.split(` +`,1)[0],R=!k.trim(),f=0;if(this.options.pedantic?(f=2,p=k.trimStart()):R?f=t[1].length+1:(f=k.search(this.rules.other.nonSpaceChar),f=f>4?1:f,p=k.slice(f),f+=t[1].length),R&&this.rules.other.blankLine.test(h)&&(c+=h+` +`,e=e.substring(h.length+1),a=!0),!a){let S=this.rules.other.nextBulletRegex(f),te=this.rules.other.hrRegex(f),ne=this.rules.other.fencesBeginRegex(f),re=this.rules.other.headingBeginRegex(f),be=this.rules.other.htmlBeginRegex(f),Re=this.rules.other.blockquoteBeginRegex(f);for(;e;){let G=e.split(` +`,1)[0],C;if(h=G,this.options.pedantic?(h=h.replace(this.rules.other.listReplaceNesting," "),C=h):C=h.replace(this.rules.other.tabCharGlobal," "),ne.test(h)||re.test(h)||be.test(h)||Re.test(h)||S.test(h)||te.test(h))break;if(C.search(this.rules.other.nonSpaceChar)>=f||!h.trim())p+=` +`+C.slice(f);else{if(R||k.replace(this.rules.other.tabCharGlobal," ").search(this.rules.other.nonSpaceChar)>=4||ne.test(k)||re.test(k)||te.test(k))break;p+=` +`+h}R=!h.trim(),c+=G+` +`,e=e.substring(G.length+1),k=C.slice(f)}}r.loose||(o?r.loose=!0:this.rules.other.doubleBlankLine.test(c)&&(o=!0)),r.items.push({type:"list_item",raw:c,task:!!this.options.gfm&&this.rules.other.listIsTask.test(p),loose:!1,text:p,tokens:[]}),r.raw+=c}let u=r.items.at(-1);if(u)u.raw=u.raw.trimEnd(),u.text=u.text.trimEnd();else return;r.raw=r.raw.trimEnd();for(let a of r.items){this.lexer.state.top=!1,a.tokens=this.lexer.blockTokens(a.text,[]);let c=a.tokens[0];if(a.task&&(c?.type==="text"||c?.type==="paragraph")){a.text=a.text.replace(this.rules.other.listReplaceTask,""),c.raw=c.raw.replace(this.rules.other.listReplaceTask,""),c.text=c.text.replace(this.rules.other.listReplaceTask,"");for(let k=this.lexer.inlineQueue.length-1;k>=0;k--)if(this.rules.other.listIsTask.test(this.lexer.inlineQueue[k].src)){this.lexer.inlineQueue[k].src=this.lexer.inlineQueue[k].src.replace(this.rules.other.listReplaceTask,"");break}let p=this.rules.other.listTaskCheckbox.exec(a.raw);if(p){let k={type:"checkbox",raw:p[0]+" ",checked:p[0]!=="[ ]"};a.checked=k.checked,r.loose?a.tokens[0]&&["paragraph","text"].includes(a.tokens[0].type)&&"tokens"in a.tokens[0]&&a.tokens[0].tokens?(a.tokens[0].raw=k.raw+a.tokens[0].raw,a.tokens[0].text=k.raw+a.tokens[0].text,a.tokens[0].tokens.unshift(k)):a.tokens.unshift({type:"paragraph",raw:k.raw,text:k.raw,tokens:[k]}):a.tokens.unshift(k)}}else a.task&&(a.task=!1);if(!r.loose){let p=a.tokens.filter(h=>h.type==="space"),k=p.length>0&&p.some(h=>this.rules.other.anyLine.test(h.raw));r.loose=k}}if(r.loose)for(let a of r.items){a.loose=!0;for(let c of a.tokens)c.type==="text"&&(c.type="paragraph")}return r}}html(e){let t=this.rules.block.html.exec(e);if(t){let n=ee(t[0]);return{type:"html",block:!0,raw:n,pre:t[1]==="pre"||t[1]==="script"||t[1]==="style",text:n}}}def(e){let t=this.rules.block.def.exec(e);if(t){let n=t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal," "),s=t[2]?t[2].replace(this.rules.other.hrefBrackets,"$1").replace(this.rules.inline.anyPunctuation,"$1"):"",r=t[3]?t[3].substring(1,t[3].length-1).replace(this.rules.inline.anyPunctuation,"$1"):t[3];return{type:"def",tag:n,raw:$(t[0],` +`),href:s,title:r}}}table(e){let t=this.rules.block.table.exec(e);if(!t||!this.rules.other.tableDelimiter.test(t[2]))return;let n=Y(t[1]),s=t[2].replace(this.rules.other.tableAlignChars,"").split("|"),r=t[3]?.trim()?t[3].replace(this.rules.other.tableRowBlankLine,"").split(` +`):[],i={type:"table",raw:$(t[0],` +`),header:[],align:[],rows:[]};if(n.length===s.length){for(let o of s)this.rules.other.tableAlignRight.test(o)?i.align.push("right"):this.rules.other.tableAlignCenter.test(o)?i.align.push("center"):this.rules.other.tableAlignLeft.test(o)?i.align.push("left"):i.align.push(null);for(let o=0;o({text:u,tokens:this.lexer.inline(u),header:!1,align:i.align[a]})));return i}}lheading(e){let t=this.rules.block.lheading.exec(e);if(t){let n=t[1].trim();return{type:"heading",raw:$(t[0],` +`),depth:t[2].charAt(0)==="="?1:2,text:n,tokens:this.lexer.inline(n)}}}paragraph(e){let t=this.rules.block.paragraph.exec(e);if(t){let 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){let 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){let t=this.rules.inline.escape.exec(e);if(t)return{type:"escape",raw:t[0],text:t[1]}}tag(e){let 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){let t=this.rules.inline.link.exec(e);if(t){let n=t[2].trim();if(!this.options.pedantic&&this.rules.other.startAngleBracket.test(n)){if(!this.rules.other.endAngleBracket.test(n))return;let i=$(n.slice(0,-1),"\\");if((n.length-i.length)%2===0)return}else{let i=fe(t[2],"()");if(i===-2)return;if(i>-1){let u=(t[0].indexOf("!")===0?5:4)+t[1].length+i;t[2]=t[2].substring(0,i),t[0]=t[0].substring(0,u).trim(),t[3]=""}}let s=t[2],r="";if(this.options.pedantic){let i=this.rules.other.pedanticHrefTitle.exec(s);i&&(s=i[1],r=i[3])}else r=t[3]?t[3].slice(1,-1):"";return s=s.trim(),this.rules.other.startAngleBracket.test(s)&&(this.options.pedantic&&!this.rules.other.endAngleBracket.test(n)?s=s.slice(1):s=s.slice(1,-1)),xe(t,{href:s&&s.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))){let s=(n[2]||n[1]).replace(this.rules.other.multipleSpaceGlobal," "),r=t[s.toLowerCase()];if(!r){let i=n[0].charAt(0);return{type:"text",raw:i,text:i}}return xe(n,r,n[0],this.lexer,this.rules)}}emStrong(e,t,n=""){let s=this.rules.inline.emStrongLDelim.exec(e);if(!s||!s[1]&&!s[2]&&!s[3]&&!s[4]||s[4]&&n.match(this.rules.other.unicodeAlphaNumeric))return;if(!(s[1]||s[3]||"")||!n||this.rules.inline.punctuation.exec(n)){let i=[...s[0]].length-1,o,u,a=i,c=0,p=s[0][0]==="*"?this.rules.inline.emStrongRDelimAst:this.rules.inline.emStrongRDelimUnd;for(p.lastIndex=0,t=t.slice(-1*e.length+i);(s=p.exec(t))!==null;){if(o=s[1]||s[2]||s[3]||s[4]||s[5]||s[6],!o)continue;if(u=[...o].length,s[3]||s[4]){a+=u;continue}else if((s[5]||s[6])&&i%3&&!((i+u)%3)){c+=u;continue}if(a-=u,a>0)continue;u=Math.min(u,u+a+c);let k=[...s[0]][0].length,h=e.slice(0,i+s.index+k+u);if(Math.min(i,u)%2){let f=h.slice(1,-1);return{type:"em",raw:h,text:f,tokens:this.lexer.inlineTokens(f)}}let R=h.slice(2,-2);return{type:"strong",raw:h,text:R,tokens:this.lexer.inlineTokens(R)}}}}codespan(e){let t=this.rules.inline.code.exec(e);if(t){let n=t[2].replace(this.rules.other.newLineCharGlobal," "),s=this.rules.other.nonSpaceChar.test(n),r=this.rules.other.startingSpaceChar.test(n)&&this.rules.other.endingSpaceChar.test(n);return s&&r&&(n=n.substring(1,n.length-1)),{type:"codespan",raw:t[0],text:n}}}br(e){let t=this.rules.inline.br.exec(e);if(t)return{type:"br",raw:t[0]}}del(e,t,n=""){let s=this.rules.inline.delLDelim.exec(e);if(!s)return;if(!(s[1]||"")||!n||this.rules.inline.punctuation.exec(n)){let i=[...s[0]].length-1,o,u,a=i,c=this.rules.inline.delRDelim;for(c.lastIndex=0,t=t.slice(-1*e.length+i);(s=c.exec(t))!==null;){if(o=s[1]||s[2]||s[3]||s[4]||s[5]||s[6],!o||(u=[...o].length,u!==i))continue;if(s[3]||s[4]){a+=u;continue}if(a-=u,a>0)continue;u=Math.min(u,u+a);let p=[...s[0]][0].length,k=e.slice(0,i+s.index+p+u),h=k.slice(i,-i);return{type:"del",raw:k,text:h,tokens:this.lexer.inlineTokens(h)}}}}autolink(e){let t=this.rules.inline.autolink.exec(e);if(t){let n,s;return t[2]==="@"?(n=t[1],s="mailto:"+n):(n=t[1],s=n),{type:"link",raw:t[0],text:n,href:s,tokens:[{type:"text",raw:n,text:n}]}}}url(e){let t;if(t=this.rules.inline.url.exec(e)){let n,s;if(t[2]==="@")n=t[0],s="mailto:"+n;else{let r;do r=t[0],t[0]=this.rules.inline._backpedal.exec(t[0])?.[0]??"";while(r!==t[0]);n=t[0],t[1]==="www."?s="http://"+t[0]:s=t[0]}return{type:"link",raw:t[0],text:n,href:s,tokens:[{type:"text",raw:n,text:n}]}}}inlineText(e){let t=this.rules.inline.text.exec(e);if(t){let n=this.lexer.state.inRawBlock;return{type:"text",raw:t[0],text:t[0],escaped:n}}}};var x=class l{tokens;options;state;inlineQueue;tokenizer;constructor(e){this.tokens=[],this.tokens.links=Object.create(null),this.options=e||T,this.options.tokenizer=this.options.tokenizer||new w,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options,this.tokenizer.lexer=this,this.inlineQueue=[],this.state={inLink:!1,inRawBlock:!1,top:!0};let t={other:m,block:D.normal,inline:A.normal};this.options.pedantic?(t.block=D.pedantic,t.inline=A.pedantic):this.options.gfm&&(t.block=D.gfm,this.options.breaks?t.inline=A.breaks:t.inline=A.gfm),this.tokenizer.rules=t}static get rules(){return{block:D,inline:A}}static lex(e,t){return new l(t).lex(e)}static lexInline(e,t){return new l(t).inlineTokens(e)}lex(e){e=e.replace(m.carriageReturn,` +`),this.blockTokens(e,this.tokens);for(let t=0;t(r=o.call({lexer:this},e,t))?(e=e.substring(r.raw.length),t.push(r),!0):!1))continue;if(r=this.tokenizer.space(e)){e=e.substring(r.raw.length);let o=t.at(-1);r.raw.length===1&&o!==void 0?o.raw+=` +`:t.push(r);continue}if(r=this.tokenizer.code(e)){e=e.substring(r.raw.length);let o=t.at(-1);o?.type==="paragraph"||o?.type==="text"?(o.raw+=(o.raw.endsWith(` +`)?"":` +`)+r.raw,o.text+=` +`+r.text,this.inlineQueue.at(-1).src=o.text):t.push(r);continue}if(r=this.tokenizer.fences(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.heading(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.hr(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.blockquote(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.list(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.html(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.def(e)){e=e.substring(r.raw.length);let o=t.at(-1);o?.type==="paragraph"||o?.type==="text"?(o.raw+=(o.raw.endsWith(` +`)?"":` +`)+r.raw,o.text+=` +`+r.raw,this.inlineQueue.at(-1).src=o.text):this.tokens.links[r.tag]||(this.tokens.links[r.tag]={href:r.href,title:r.title},t.push(r));continue}if(r=this.tokenizer.table(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.lheading(e)){e=e.substring(r.raw.length),t.push(r);continue}let i=e;if(this.options.extensions?.startBlock){let o=1/0,u=e.slice(1),a;this.options.extensions.startBlock.forEach(c=>{a=c.call({lexer:this},u),typeof a=="number"&&a>=0&&(o=Math.min(o,a))}),o<1/0&&o>=0&&(i=e.substring(0,o+1))}if(this.state.top&&(r=this.tokenizer.paragraph(i))){let o=t.at(-1);n&&o?.type==="paragraph"?(o.raw+=(o.raw.endsWith(` +`)?"":` +`)+r.raw,o.text+=` +`+r.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=o.text):t.push(r),n=i.length!==e.length,e=e.substring(r.raw.length);continue}if(r=this.tokenizer.text(e)){e=e.substring(r.raw.length);let o=t.at(-1);o?.type==="text"?(o.raw+=(o.raw.endsWith(` +`)?"":` +`)+r.raw,o.text+=` +`+r.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=o.text):t.push(r);continue}if(e){this.infiniteLoopError(e.charCodeAt(0));break}}return this.state.top=!0,t}inline(e,t=[]){return this.inlineQueue.push({src:e,tokens:t}),t}inlineTokens(e,t=[]){this.tokenizer.lexer=this;let n=e,s=null;if(this.tokens.links){let a=Object.keys(this.tokens.links);if(a.length>0)for(;(s=this.tokenizer.rules.inline.reflinkSearch.exec(n))!==null;)a.includes(s[0].slice(s[0].lastIndexOf("[")+1,-1))&&(n=n.slice(0,s.index)+"["+"a".repeat(s[0].length-2)+"]"+n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;(s=this.tokenizer.rules.inline.anyPunctuation.exec(n))!==null;)n=n.slice(0,s.index)+"++"+n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);let r;for(;(s=this.tokenizer.rules.inline.blockSkip.exec(n))!==null;)r=s[2]?s[2].length:0,n=n.slice(0,s.index+r)+"["+"a".repeat(s[0].length-r-2)+"]"+n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);n=this.options.hooks?.emStrongMask?.call({lexer:this},n)??n;let i=!1,o="",u=1/0;for(;e;){if(e.length(a=p.call({lexer:this},e,t))?(e=e.substring(a.raw.length),t.push(a),!0):!1))continue;if(a=this.tokenizer.escape(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.tag(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.link(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.reflink(e,this.tokens.links)){e=e.substring(a.raw.length);let p=t.at(-1);a.type==="text"&&p?.type==="text"?(p.raw+=a.raw,p.text+=a.text):t.push(a);continue}if(a=this.tokenizer.emStrong(e,n,o)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.codespan(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.br(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.del(e,n,o)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.autolink(e)){e=e.substring(a.raw.length),t.push(a);continue}if(!this.state.inLink&&(a=this.tokenizer.url(e))){e=e.substring(a.raw.length),t.push(a);continue}let c=e;if(this.options.extensions?.startInline){let p=1/0,k=e.slice(1),h;this.options.extensions.startInline.forEach(R=>{h=R.call({lexer:this},k),typeof h=="number"&&h>=0&&(p=Math.min(p,h))}),p<1/0&&p>=0&&(c=e.substring(0,p+1))}if(a=this.tokenizer.inlineText(c)){e=e.substring(a.raw.length),a.raw.slice(-1)!=="_"&&(o=a.raw.slice(-1)),i=!0;let p=t.at(-1);p?.type==="text"?(p.raw+=a.raw,p.text+=a.text):t.push(a);continue}if(e){this.infiniteLoopError(e.charCodeAt(0));break}}return t}infiniteLoopError(e){let t="Infinite loop on byte: "+e;if(this.options.silent)console.error(t);else throw new Error(t)}};var y=class{options;parser;constructor(e){this.options=e||T}space(e){return""}code({text:e,lang:t,escaped:n}){let s=(t||"").match(m.notSpaceStart)?.[0],r=e.replace(m.endingNewline,"")+` +`;return s?'

    '+(n?r:O(r,!0))+`
    +`:"
    "+(n?r:O(r,!0))+`
    +`}blockquote({tokens:e}){return`
    +${this.parser.parse(e)}
    +`}html({text:e}){return e}def(e){return""}heading({tokens:e,depth:t}){return`${this.parser.parseInline(e)} +`}hr(e){return`
    +`}list(e){let t=e.ordered,n=e.start,s="";for(let o=0;o +`+s+" +`}listitem(e){return`
  • ${this.parser.parse(e.tokens)}
    • +`}checkbox({checked:e}){return" '}paragraph({tokens:e}){return`

    ${this.parser.parseInline(e)}

    +`}table(e){let t="",n="";for(let r=0;r${s}`),` + +`+t+` +`+s+`
    +`}tablerow({text:e}){return` +${e} +`}tablecell(e){let 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`${O(e,!0)}`}br(e){return"
    "}del({tokens:e}){return`${this.parser.parseInline(e)}`}link({href:e,title:t,tokens:n}){let s=this.parser.parseInline(n),r=V(e);if(r===null)return s;e=r;let i='    ",i}image({href:e,title:t,text:n,tokens:s}){s&&(n=this.parser.parseInline(s,this.parser.textRenderer));let r=V(e);if(r===null)return O(n);e=r;let i=`${O(n)}{let o=r[i].flat(1/0);n=n.concat(this.walkTokens(o,t))}):r.tokens&&(n=n.concat(this.walkTokens(r.tokens,t)))}}return n}use(...e){let t=this.defaults.extensions||{renderers:{},childTokens:{}};return e.forEach(n=>{let s={...n};if(s.async=this.defaults.async||s.async||!1,n.extensions&&(n.extensions.forEach(r=>{if(!r.name)throw new Error("extension name required");if("renderer"in r){let i=t.renderers[r.name];i?t.renderers[r.name]=function(...o){let u=r.renderer.apply(this,o);return u===!1&&(u=i.apply(this,o)),u}: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'");let 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)}),s.extensions=t),n.renderer){let r=this.defaults.renderer||new y(this.defaults);for(let i in n.renderer){if(!(i in r))throw new Error(`renderer '${i}' does not exist`);if(["options","parser"].includes(i))continue;let o=i,u=n.renderer[o],a=r[o];r[o]=(...c)=>{let p=u.apply(r,c);return p===!1&&(p=a.apply(r,c)),p||""}}s.renderer=r}if(n.tokenizer){let r=this.defaults.tokenizer||new w(this.defaults);for(let i in n.tokenizer){if(!(i in r))throw new Error(`tokenizer '${i}' does not exist`);if(["options","rules","lexer"].includes(i))continue;let o=i,u=n.tokenizer[o],a=r[o];r[o]=(...c)=>{let p=u.apply(r,c);return p===!1&&(p=a.apply(r,c)),p}}s.tokenizer=r}if(n.hooks){let r=this.defaults.hooks||new P;for(let i in n.hooks){if(!(i in r))throw new Error(`hook '${i}' does not exist`);if(["options","block"].includes(i))continue;let o=i,u=n.hooks[o],a=r[o];P.passThroughHooks.has(i)?r[o]=c=>{if(this.defaults.async&&P.passThroughHooksRespectAsync.has(i))return(async()=>{let k=await u.call(r,c);return a.call(r,k)})();let p=u.call(r,c);return a.call(r,p)}:r[o]=(...c)=>{if(this.defaults.async)return(async()=>{let k=await u.apply(r,c);return k===!1&&(k=await a.apply(r,c)),k})();let p=u.apply(r,c);return p===!1&&(p=a.apply(r,c)),p}}s.hooks=r}if(n.walkTokens){let r=this.defaults.walkTokens,i=n.walkTokens;s.walkTokens=function(o){let u=[];return u.push(i.call(this,o)),r&&(u=u.concat(r.call(this,o))),u}}this.defaults={...this.defaults,...s}}),this}setOptions(e){return this.defaults={...this.defaults,...e},this}lexer(e,t){return x.lex(e,t??this.defaults)}parser(e,t){return b.parse(e,t??this.defaults)}parseMarkdown(e){return(n,s)=>{let r={...s},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"));if(i.hooks&&(i.hooks.options=i,i.hooks.block=e),i.async)return(async()=>{let u=i.hooks?await i.hooks.preprocess(n):n,c=await(i.hooks?await i.hooks.provideLexer(e):e?x.lex:x.lexInline)(u,i),p=i.hooks?await i.hooks.processAllTokens(c):c;i.walkTokens&&await Promise.all(this.walkTokens(p,i.walkTokens));let h=await(i.hooks?await i.hooks.provideParser(e):e?b.parse:b.parseInline)(p,i);return i.hooks?await i.hooks.postprocess(h):h})().catch(o);try{i.hooks&&(n=i.hooks.preprocess(n));let a=(i.hooks?i.hooks.provideLexer(e):e?x.lex:x.lexInline)(n,i);i.hooks&&(a=i.hooks.processAllTokens(a)),i.walkTokens&&this.walkTokens(a,i.walkTokens);let p=(i.hooks?i.hooks.provideParser(e):e?b.parse:b.parseInline)(a,i);return i.hooks&&(p=i.hooks.postprocess(p)),p}catch(u){return o(u)}}}onError(e,t){return n=>{if(n.message+=` +Please report this to https://github.com/markedjs/marked.`,e){let s="

    An error occurred:

    "+O(n.message+"",!0)+"
    ";return t?Promise.resolve(s):s}if(t)return Promise.reject(n);throw n}}};var z=new q;function g(l,e){return z.parse(l,e)}g.options=g.setOptions=function(l){return z.setOptions(l),g.defaults=z.defaults,N(g.defaults),g};g.getDefaults=M;g.defaults=T;g.use=function(...l){return z.use(...l),g.defaults=z.defaults,N(g.defaults),g};g.walkTokens=function(l,e){return z.walkTokens(l,e)};g.parseInline=z.parseInline;g.Parser=b;g.parser=b.parse;g.Renderer=y;g.TextRenderer=L;g.Lexer=x;g.lexer=x.lex;g.Tokenizer=w;g.Hooks=P;g.parse=g;var Ft=g.options,Ut=g.setOptions,Kt=g.use,Wt=g.walkTokens,Xt=g.parseInline,Jt=g,Vt=b.parse,Yt=x.lex;export{P as Hooks,x as Lexer,q as Marked,b as Parser,y as Renderer,L as TextRenderer,w as Tokenizer,T as defaults,M as getDefaults,Yt as lexer,g as marked,Ft as options,Jt as parse,Xt as parseInline,Vt as parser,Ut as setOptions,Kt as use,Wt as walkTokens}; +//# sourceMappingURL=marked.esm.js.map diff --git a/frontend/node_modules/marked/lib/marked.esm.js.map b/frontend/node_modules/marked/lib/marked.esm.js.map new file mode 100644 index 0000000..1ab74b5 --- /dev/null +++ b/frontend/node_modules/marked/lib/marked.esm.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../src/defaults.ts", "../src/rules.ts", "../src/helpers.ts", "../src/Tokenizer.ts", "../src/Lexer.ts", "../src/Renderer.ts", "../src/TextRenderer.ts", "../src/Parser.ts", "../src/Hooks.ts", "../src/Instance.ts", "../src/marked.ts"], + "sourcesContent": ["import type { MarkedOptions } from './MarkedOptions.ts';\n\n/**\n * Gets the original marked default options.\n */\nexport function _getDefaults(): MarkedOptions {\n return {\n async: false,\n breaks: false,\n extensions: null,\n gfm: true,\n hooks: null,\n pedantic: false,\n renderer: null,\n silent: false,\n tokenizer: null,\n walkTokens: null,\n };\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport let _defaults: MarkedOptions = _getDefaults();\n\nexport function changeDefaults(newDefaults: MarkedOptions) {\n _defaults = newDefaults;\n}\n", "const noopTest = { exec: () => null } as unknown as RegExp;\n\nfunction cachedIndentRegex(createRegex: (indent: number) => RegExp) {\n const cache: RegExp[] = [];\n return (indent: number) => {\n const cacheIndex = Math.max(0, Math.min(3, indent - 1));\n let regex = cache[cacheIndex];\n if (!regex) {\n regex = createRegex(cacheIndex);\n cache[cacheIndex] = regex;\n }\n return regex;\n };\n}\n\nfunction edit(regex: string | RegExp, opt = '') {\n let source = typeof regex === 'string' ? regex : regex.source;\n const obj = {\n replace: (name: string | RegExp, val: string | RegExp) => {\n let valSource = typeof val === 'string' ? val : val.source;\n valSource = valSource.replace(other.caret, '$1');\n source = source.replace(name, valSource);\n return obj;\n },\n getRegex: () => {\n return new RegExp(source, opt);\n },\n };\n return obj;\n}\n\n// use a default variable to ensure the regex is evaluated on client an not removed by minifiers\nconst supportsLookbehind = ((a = '') => {\ntry {\n return !!new RegExp('(?<=1)(?/,\n blockquoteSetextReplace: /\\n {0,3}((?:=+|-+) *)(?=\\n|$)/g,\n blockquoteSetextReplace2: /^ {0,3}>[ \\t]?/gm,\n listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,\n listIsTask: /^\\[[ xX]\\] +\\S/,\n listReplaceTask: /^\\[[ xX]\\] +/,\n listTaskCheckbox: /\\[[ xX]\\]/,\n anyLine: /\\n.*\\n/,\n hrefBrackets: /^<(.*)>$/,\n tableDelimiter: /[:|]/,\n tableAlignChars: /^\\||\\| *$/g,\n tableRowBlankLine: /\\n[ \\t]*$/,\n tableAlignRight: /^ *-+: *$/,\n tableAlignCenter: /^ *:-+: *$/,\n tableAlignLeft: /^ *:-+ *$/,\n startATag: /^    /i,\n startPreScriptTag: /^<(pre|code|kbd|script)(\\s|>)/i,\n endPreScriptTag: /^<\\/(pre|code|kbd|script)(\\s|>)/i,\n startAngleBracket: /^$/,\n pedanticHrefTitle: /^([^'\"]*[^\\s])\\s+(['\"])(.*)\\2/,\n unicodeAlphaNumeric: /[\\p{L}\\p{N}]/u,\n escapeTest: /[&<>\"']/,\n escapeReplace: /[&<>\"']/g,\n escapeTestNoEncode: /[<>\"']|&(?!(#\\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\\w+);)/,\n escapeReplaceNoEncode: /[<>\"']|&(?!(#\\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\\w+);)/g,\n caret: /(^|[^\\[])\\^/g,\n percentDecode: /%25/g,\n findPipe: /\\|/g,\n splitPipe: / \\|/,\n slashPipe: /\\\\\\|/g,\n carriageReturn: /\\r\\n|\\r/g,\n spaceLine: /^ +$/gm,\n notSpaceStart: /^\\S*/,\n endingNewline: /\\n$/,\n listItemRegex: (bull: string) => new RegExp(`^( {0,3}${bull})((?:[\\t ][^\\\\n]*)?(?:\\\\n|$))`),\n nextBulletRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}(?:[*+-]|\\\\d{1,9}[.)])((?:[ \\t][^\\\\n]*)?(?:\\\\n|$))`)),\n hrRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}((?:- *){3,}|(?:_ *){3,}|(?:\\\\* *){3,})(?:\\\\n+|$)`)),\n fencesBeginRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}(?:\\`\\`\\`|~~~)`)),\n headingBeginRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}#`)),\n htmlBeginRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}<(?:[a-z].*>|!--)`, 'i')),\n blockquoteBeginRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}>`)),\n};\n\n/**\n * Block-Level Grammar\n */\n\nconst newline = /^(?:[ \\t]*(?:\\n|$))+/;\nconst blockCode = /^((?: {4}| {0,3}\\t)[^\\n]+(?:\\n(?:[ \\t]*(?:\\n|$))*)?)+/;\nconst fences = /^ {0,3}(`{3,}(?=[^`\\n]*(?:\\n|$))|~{3,})([^\\n]*)(?:\\n|$)(?:|([\\s\\S]*?)(?:\\n|$))(?: {0,3}\\1[~`]* *(?=\\n|$)|$)/;\nconst hr = /^ {0,3}((?:-[\\t ]*){3,}|(?:_[ \\t]*){3,}|(?:\\*[ \\t]*){3,})(?:\\n+|$)/;\nconst heading = /^ {0,3}(#{1,6})(?=\\s|$)(.*)(?:\\n+|$)/;\nconst bullet = / {0,3}(?:[*+-]|\\d{1,9}[.)])/;\nconst lheadingCore = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\\n(?!\\s*?\\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/;\nconst lheading = edit(lheadingCore)\n .replace(/bull/g, bullet) // lists can interrupt\n .replace(/blockCode/g, /(?: {4}| {0,3}\\t)/) // indented code blocks can interrupt\n .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt\n .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt\n .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt\n .replace(/html/g, / {0,3}<[^\\n>]+>\\n/) // block html can interrupt\n .replace(/\\|table/g, '') // table not in commonmark\n .getRegex();\nconst lheadingGfm = edit(lheadingCore)\n .replace(/bull/g, bullet) // lists can interrupt\n .replace(/blockCode/g, /(?: {4}| {0,3}\\t)/) // indented code blocks can interrupt\n .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt\n .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt\n .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt\n .replace(/html/g, / {0,3}<[^\\n>]+>\\n/) // block html can interrupt\n .replace(/table/g, / {0,3}\\|?(?:[:\\- ]*\\|)+[\\:\\- ]*\\n/) // table can interrupt\n .getRegex();\nconst _paragraph = /^([^\\n]+(?:\\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\\n)[^\\n]+)*)/;\nconst blockText = /^[^\\n]+/;\nconst _blockLabel = /(?!\\s*\\])(?:\\\\[\\s\\S]|[^\\[\\]\\\\])+/;\nconst def = edit(/^ {0,3}\\[(label)\\]: *(?:\\n[ \\t]*)?([^<\\s][^\\s]*|<.*?>)(?:(?: +(?:\\n[ \\t]*)?| *\\n[ \\t]*)(title))? *(?:\\n+|$)/)\n .replace('label', _blockLabel)\n .replace('title', /(?:\"(?:\\\\\"?|[^\"\\\\])*\"|'[^'\\n]*(?:\\n[^'\\n]+)*\\n?'|\\([^()]*\\))/)\n .getRegex();\n\nconst list = edit(/^(bull)([ \\t][^\\n]*?)?(?:\\n|$)/)\n .replace(/bull/g, bullet)\n .getRegex();\n\nconst _tag = 'address|article|aside|base|basefont|blockquote|body|caption'\n + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'\n + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'\n + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'\n + '|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title'\n + '|tr|track|ul';\nconst _comment = /|$))/;\nconst html = edit(\n '^ {0,3}(?:' // optional indentation\n+ '<(script|pre|style|textarea)[\\\\s>][\\\\s\\\\S]*?(?:[^\\\\n]*\\\\n+|$)' // (1)\n+ '|comment[^\\\\n]*(\\\\n+|$)' // (2)\n+ '|<\\\\?[\\\\s\\\\S]*?(?:\\\\?>\\\\n*|$)' // (3)\n+ '|\\\\n*|$)' // (4)\n+ '|\\\\n*|$)' // (5)\n+ '|)[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (6)\n+ '|<(?!script|pre|style|textarea)([a-z][\\\\w-]*)(?:attribute)*? */?>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (7) open tag\n+ '|(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (7) closing tag\n+ ')', 'i')\n .replace('comment', _comment)\n .replace('tag', _tag)\n .replace('attribute', / +[a-zA-Z:_][\\w.:-]*(?: *= *\"[^\"\\n]*\"| *= *'[^'\\n]*'| *= *[^\\s\"'=<>`]+)?/)\n .getRegex();\n\nconst paragraph = edit(_paragraph)\n .replace('hr', hr)\n .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs\n .replace('|table', '')\n .replace('blockquote', ' {0,3}>')\n .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n .replace('list', ' {0,3}(?:[*+-]|1[.)])[ \\\\t]+[^ \\\\t\\\\n]') // only non-empty lists starting from 1 can interrupt\n .replace('html', ')|<(?:script|pre|style|textarea|!--)')\n .replace('tag', _tag) // pars can be interrupted by type (6) html blocks\n .getRegex();\n\nconst blockquote = edit(/^( {0,3}> ?(paragraph|[^\\n]*)(?:\\n|$))+/)\n .replace('paragraph', paragraph)\n .getRegex();\n\n/**\n * Normal Block Grammar\n */\n\nconst blockNormal = {\n blockquote,\n code: blockCode,\n def,\n fences,\n heading,\n hr,\n html,\n lheading,\n list,\n newline,\n paragraph,\n table: noopTest,\n text: blockText,\n};\n\ntype BlockKeys = keyof typeof blockNormal;\n\n/**\n * GFM Block Grammar\n */\n\nconst gfmTable = edit(\n '^ *([^\\\\n ].*)\\\\n' // Header\n+ ' {0,3}((?:\\\\| *)?:?-+:? *(?:\\\\| *:?-+:? *)*(?:\\\\| *)?)' // Align\n+ '(?:\\\\n((?:(?! *\\\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\\\n|$))*)\\\\n*|$)') // Cells\n .replace('hr', hr)\n .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n .replace('blockquote', ' {0,3}>')\n .replace('code', '(?: {4}| {0,3}\\t)[^\\\\n]')\n .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n .replace('list', ' {0,3}(?:[*+-]|1[.)])[ \\\\t]') // any bullet ends the table rows\n .replace('html', ')|<(?:script|pre|style|textarea|!--)')\n .replace('tag', _tag) // tables can be interrupted by type (6) html blocks\n .getRegex();\n\nconst blockGfm: Record = {\n ...blockNormal,\n lheading: lheadingGfm,\n table: gfmTable,\n paragraph: edit(_paragraph)\n .replace('hr', hr)\n .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs\n .replace('table', gfmTable) // interrupt paragraphs with table\n .replace('blockquote', ' {0,3}>')\n .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n .replace('list', ' {0,3}(?:[*+-]|1[.)])[ \\\\t]+[^ \\\\t\\\\n]') // only non-empty lists starting from 1 can interrupt\n .replace('html', ')|<(?:script|pre|style|textarea|!--)')\n .replace('tag', _tag) // pars can be interrupted by type (6) html blocks\n .getRegex(),\n};\n\n/**\n * Pedantic grammar (original John Gruber's loose markdown specification)\n */\n\nconst blockPedantic: Record = {\n ...blockNormal,\n html: edit(\n '^ *(?:comment *(?:\\\\n|\\\\s*$)'\n + '|<(tag)[\\\\s\\\\S]+? *(?:\\\\n{2,}|\\\\s*$)' // closed tag\n + '|\\\\s]*)*?/?> *(?:\\\\n{2,}|\\\\s*$))')\n .replace('comment', _comment)\n .replace(/tag/g, '(?!(?:'\n + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub'\n + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)'\n + '\\\\b)\\\\w+(?!:|[^\\\\w\\\\s@]*@)\\\\b')\n .getRegex(),\n def: /^ *\\[([^\\]]+)\\]: *]+)>?(?: +([\"(][^\\n]+[\")]))? *(?:\\n+|$)/,\n heading: /^(#{1,6})(.*)(?:\\n+|$)/,\n fences: noopTest, // fences not supported\n lheading: /^(.+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/,\n paragraph: edit(_paragraph)\n .replace('hr', hr)\n .replace('heading', ' *#{1,6} *[^\\n]')\n .replace('lheading', lheading)\n .replace('|table', '')\n .replace('blockquote', ' {0,3}>')\n .replace('|fences', '')\n .replace('|list', '')\n .replace('|html', '')\n .replace('|tag', '')\n .getRegex(),\n};\n\n/**\n * Inline-Level Grammar\n */\n\nconst escape = /^\\\\([!\"#$%&'()*+,\\-./:;<=>?@\\[\\]\\\\^_`{|}~])/;\nconst inlineCode = /^(`+)([^`]|[^`][\\s\\S]*?[^`])\\1(?!`)/;\nconst br = /^( {2,}|\\\\)\\n(?!\\s*$)/;\nconst inlineText = /^(`+|[^`])(?:(?= {2,}\\n)|[\\s\\S]*?(?:(?=[\\\\\nconst blockSkip = edit(/link|precode-code|html/, 'g')\n .replace('link', /\\[(?:[^\\[\\]`]|(?`+)[^`]+\\k(?!`))*?\\]\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)]|\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)])*\\))*\\)/)\n .replace('precode-', supportsLookbehind ? '(?`+)[^`]+\\k(?!`)/)\n .replace('html', /<(?! )[^<>]*?>/)\n .getRegex();\n\nconst emStrongLDelimCore = /^(?:\\*+(?:((?!\\*)punct)|([^\\s*]))?)|^_+(?:((?!_)punct)|([^\\s_]))?/;\n\nconst emStrongLDelim = edit(emStrongLDelimCore, 'u')\n .replace(/punct/g, _punctuation)\n .getRegex();\n\nconst emStrongLDelimGfm = edit(emStrongLDelimCore, 'u')\n .replace(/punct/g, _punctuationGfmStrongEm)\n .getRegex();\n\nconst emStrongRDelimAstCore =\n '^[^_*]*?__[^_*]*?\\\\*[^_*]*?(?=__)' // Skip orphan inside strong\n+ '|[^*]+(?=[^*])' // Consume to delim\n+ '|(?!\\\\*)punct(\\\\*+)(?=[\\\\s]|$)' // (1) #*** can only be a Right Delimiter\n+ '|notPunctSpace(\\\\*+)(?!\\\\*)(?=punctSpace|$)' // (2) a***#, a*** can only be a Right Delimiter\n+ '|(?!\\\\*)punctSpace(\\\\*+)(?=notPunctSpace)' // (3) #***a, ***a can only be Left Delimiter\n+ '|[\\\\s](\\\\*+)(?!\\\\*)(?=punct)' // (4) ***# can only be Left Delimiter\n+ '|(?!\\\\*)punct(\\\\*+)(?!\\\\*)(?=punct)' // (5) #***# can be either Left or Right Delimiter\n+ '|notPunctSpace(\\\\*+)(?=notPunctSpace)'; // (6) a***a can be either Left or Right Delimiter\n\nconst emStrongRDelimAst = edit(emStrongRDelimAstCore, 'gu')\n .replace(/notPunctSpace/g, _notPunctuationOrSpace)\n .replace(/punctSpace/g, _punctuationOrSpace)\n .replace(/punct/g, _punctuation)\n .getRegex();\n\nconst emStrongRDelimAstGfm = edit(emStrongRDelimAstCore, 'gu')\n .replace(/notPunctSpace/g, _notPunctuationOrSpaceGfmStrongEm)\n .replace(/punctSpace/g, _punctuationOrSpaceGfmStrongEm)\n .replace(/punct/g, _punctuationGfmStrongEm)\n .getRegex();\n\n// (6) Not allowed for _\nconst emStrongRDelimUnd = edit(\n '^[^_*]*?\\\\*\\\\*[^_*]*?_[^_*]*?(?=\\\\*\\\\*)' // Skip orphan inside strong\n+ '|[^_]+(?=[^_])' // Consume to delim\n+ '|(?!_)punct(_+)(?=[\\\\s]|$)' // (1) #___ can only be a Right Delimiter\n+ '|notPunctSpace(_+)(?!_)(?=punctSpace|$)' // (2) a___#, a___ can only be a Right Delimiter\n+ '|(?!_)punctSpace(_+)(?=notPunctSpace)' // (3) #___a, ___a can only be Left Delimiter\n+ '|[\\\\s](_+)(?!_)(?=punct)' // (4) ___# can only be Left Delimiter\n+ '|(?!_)punct(_+)(?!_)(?=punct)', 'gu') // (5) #___# can be either Left or Right Delimiter\n .replace(/notPunctSpace/g, _notPunctuationOrSpace)\n .replace(/punctSpace/g, _punctuationOrSpace)\n .replace(/punct/g, _punctuation)\n .getRegex();\n\n// Tilde left delimiter for strikethrough (similar to emStrongLDelim for asterisk)\nconst delLDelim = edit(/^~~?(?:((?!~)punct)|[^\\s~])/, 'u')\n .replace(/punct/g, _punctuation)\n .getRegex();\n\n// Tilde delimiter patterns for strikethrough (similar to asterisk)\nconst delRDelimCore =\n '^[^~]+(?=[^~])' // Consume to delim\n+ '|(?!~)punct(~~?)(?=[\\\\s]|$)' // (1) #~~ can only be a Right Delimiter\n+ '|notPunctSpace(~~?)(?!~)(?=punctSpace|$)' // (2) a~~#, a~~ can only be a Right Delimiter\n+ '|(?!~)punctSpace(~~?)(?=notPunctSpace)' // (3) #~~a, ~~a can only be Left Delimiter\n+ '|[\\\\s](~~?)(?!~)(?=punct)' // (4) ~~# can only be Left Delimiter\n+ '|(?!~)punct(~~?)(?!~)(?=punct)' // (5) #~~# can be either Left or Right Delimiter\n+ '|notPunctSpace(~~?)(?=notPunctSpace)'; // (6) a~~a can be either Left or Right Delimiter\n\nconst delRDelim = edit(delRDelimCore, 'gu')\n .replace(/notPunctSpace/g, _notPunctuationOrSpace)\n .replace(/punctSpace/g, _punctuationOrSpace)\n .replace(/punct/g, _punctuation)\n .getRegex();\n\nconst anyPunctuation = edit(/\\\\(punct)/, 'gu')\n .replace(/punct/g, _punctuation)\n .getRegex();\n\nconst autolink = edit(/^<(scheme:[^\\s\\x00-\\x1f<>]*|email)>/)\n .replace('scheme', /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/)\n .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])?)+(?![-_])/)\n .getRegex();\n\nconst _inlineComment = edit(_comment).replace('(?:-->|$)', '-->').getRegex();\nconst tag = edit(\n '^comment'\n + '|^' // self-closing tag\n + '|^<[a-zA-Z][\\\\w-]*(?:attribute)*?\\\\s*/?>' // open tag\n + '|^<\\\\?[\\\\s\\\\S]*?\\\\?>' // processing instruction, e.g. \n + '|^' // declaration, e.g. \n + '|^') // CDATA section\n .replace('comment', _inlineComment)\n .replace('attribute', /\\s+[a-zA-Z:_][\\w.:-]*(?:\\s*=\\s*\"[^\"]*\"|\\s*=\\s*'[^']*'|\\s*=\\s*[^\\s\"'=<>`]+)?/)\n .getRegex();\n\nconst _inlineLabel = /(?:\\[(?:\\\\[\\s\\S]|[^\\[\\]\\\\])*\\]|\\\\[\\s\\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\\])|[^\\[\\]\\\\`])*?/;\n\nconst link = edit(/^!?\\[(label)\\]\\(\\s*(href)(?:(?:[ \\t]+(?:\\n[ \\t]*)?|\\n[ \\t]*)(title))?\\s*\\)/)\n .replace('label', _inlineLabel)\n .replace('href', /<(?:\\\\.|[^\\n<>\\\\])+>|[^ \\t\\n\\x00-\\x1f]*/)\n .replace('title', /\"(?:\\\\\"?|[^\"\\\\])*\"|'(?:\\\\'?|[^'\\\\])*'|\\((?:\\\\\\)?|[^)\\\\])*\\)/)\n .getRegex();\n\nconst reflink = edit(/^!?\\[(label)\\]\\[(ref)\\]/)\n .replace('label', _inlineLabel)\n .replace('ref', _blockLabel)\n .getRegex();\n\nconst nolink = edit(/^!?\\[(ref)\\](?:\\[\\])?/)\n .replace('ref', _blockLabel)\n .getRegex();\n\nconst reflinkSearch = edit('reflink|nolink(?!\\\\()', 'g')\n .replace('reflink', reflink)\n .replace('nolink', nolink)\n .getRegex();\n\nconst _caseInsensitiveProtocol = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/;\n\n/**\n * Normal Inline Grammar\n */\n\nconst inlineNormal = {\n _backpedal: noopTest, // only used for GFM url\n anyPunctuation,\n autolink,\n blockSkip,\n br,\n code: inlineCode,\n del: noopTest,\n delLDelim: noopTest,\n delRDelim: noopTest,\n emStrongLDelim,\n emStrongRDelimAst,\n emStrongRDelimUnd,\n escape,\n link,\n nolink,\n punctuation,\n reflink,\n reflinkSearch,\n tag,\n text: inlineText,\n url: noopTest,\n};\n\ntype InlineKeys = keyof typeof inlineNormal;\n\n/**\n * Pedantic Inline Grammar\n */\n\nconst inlinePedantic: Record = {\n ...inlineNormal,\n link: edit(/^!?\\[(label)\\]\\((.*?)\\)/)\n .replace('label', _inlineLabel)\n .getRegex(),\n reflink: edit(/^!?\\[(label)\\]\\s*\\[([^\\]]*)\\]/)\n .replace('label', _inlineLabel)\n .getRegex(),\n};\n\n/**\n * GFM Inline Grammar\n */\n\nconst inlineGfm: Record = {\n ...inlineNormal,\n emStrongRDelimAst: emStrongRDelimAstGfm,\n emStrongLDelim: emStrongLDelimGfm,\n delLDelim,\n delRDelim,\n url: edit(/^((?:protocol):\\/\\/|www\\.)(?:[a-zA-Z0-9\\-]+\\.?)+[^\\s<]*|^email/)\n .replace('protocol', _caseInsensitiveProtocol)\n .replace('email', /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/)\n .getRegex(),\n _backpedal: /(?:[^?!.,:;*_'\"~()&]+|\\([^)]*\\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'\"~)]+(?!$))+/,\n del: /^(~~?)(?=[^\\s~])((?:\\\\[\\s\\S]|[^\\\\])*?(?:\\\\[\\s\\S]|[^\\s~\\\\]))\\1(?=[^~]|$)/,\n text: edit(/^([`~]+|[^`~])(?:(?= {2,}\\n)|(?=[a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-]+@)|[\\s\\S]*?(?:(?=[\\\\ = {\n ...inlineGfm,\n br: edit(br).replace('{2,}', '*').getRegex(),\n text: edit(inlineGfm.text)\n .replace('\\\\b_', '\\\\b_| {2,}\\\\n')\n .replace(/\\{2,\\}/g, '*')\n .getRegex(),\n};\n\n/**\n * exports\n */\n\nexport const block = {\n normal: blockNormal,\n gfm: blockGfm,\n pedantic: blockPedantic,\n};\n\nexport const inline = {\n normal: inlineNormal,\n gfm: inlineGfm,\n breaks: inlineBreaks,\n pedantic: inlinePedantic,\n};\n\nexport interface Rules {\n other: typeof other\n block: Record\n inline: Record\n}\n", "import { other } from './rules.ts';\n\n/**\n * Helpers\n */\nconst escapeReplacements: { [index: string]: string } = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": ''',\n};\nconst getEscapeReplacement = (ch: string) => escapeReplacements[ch];\n\nexport function escapeHtmlEntities(html: string, encode?: boolean) {\n if (encode) {\n if (other.escapeTest.test(html)) {\n return html.replace(other.escapeReplace, getEscapeReplacement);\n }\n } else {\n if (other.escapeTestNoEncode.test(html)) {\n return html.replace(other.escapeReplaceNoEncode, getEscapeReplacement);\n }\n }\n\n return html;\n}\n\nexport function cleanUrl(href: string) {\n try {\n href = encodeURI(href).replace(other.percentDecode, '%');\n } catch {\n return null;\n }\n return href;\n}\n\nexport function splitCells(tableRow: string, count?: number) {\n // ensure that every cell-delimiting pipe has a space\n // before it to distinguish it from an escaped pipe\n const row = tableRow.replace(other.findPipe, (match, offset, str) => {\n let escaped = false;\n let curr = offset;\n while (--curr >= 0 && str[curr] === '\\\\') escaped = !escaped;\n if (escaped) {\n // odd number of slashes means | is escaped\n // so we leave it alone\n return '|';\n } else {\n // add space before unescaped |\n return ' |';\n }\n }),\n cells = row.split(other.splitPipe);\n let i = 0;\n\n // First/last cell in a row cannot be empty if it has no leading/trailing pipe\n if (!cells[0].trim()) {\n cells.shift();\n }\n if (cells.length > 0 && !cells.at(-1)?.trim()) {\n cells.pop();\n }\n\n if (count) {\n if (cells.length > count) {\n cells.splice(count);\n } else {\n while (cells.length < count) cells.push('');\n }\n }\n\n for (; i < cells.length; i++) {\n // leading or trailing whitespace is ignored per the gfm spec\n cells[i] = cells[i].trim().replace(other.slashPipe, '|');\n }\n return cells;\n}\n\n/**\n * Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').\n * /c*$/ is vulnerable to REDOS.\n *\n * @param str\n * @param c\n * @param invert Remove suffix of non-c chars instead. Default falsey.\n */\nexport function rtrim(str: string, c: string, invert?: boolean) {\n const l = str.length;\n if (l === 0) {\n return '';\n }\n\n // Length of suffix matching the invert condition.\n let suffLen = 0;\n\n // Step left until we fail to match the invert condition.\n while (suffLen < l) {\n const currChar = str.charAt(l - suffLen - 1);\n if (currChar === c && !invert) {\n suffLen++;\n } else if (currChar !== c && invert) {\n suffLen++;\n } else {\n break;\n }\n }\n\n return str.slice(0, l - suffLen);\n}\n\nexport function trimTrailingBlankLines(str: string) {\n const lines = str.split('\\n');\n let end = lines.length - 1;\n while (end >= 0 && other.blankLine.test(lines[end])) {\n end--;\n }\n if (lines.length - end <= 2) {\n // we want to keep single trailing blank lines\n return str;\n }\n\n return lines.slice(0, end + 1).join('\\n');\n}\n\nexport function findClosingBracket(str: string, b: string) {\n if (str.indexOf(b[1]) === -1) {\n return -1;\n }\n\n let level = 0;\n for (let i = 0; i < str.length; i++) {\n if (str[i] === '\\\\') {\n i++;\n } else if (str[i] === b[0]) {\n level++;\n } else if (str[i] === b[1]) {\n level--;\n if (level < 0) {\n return i;\n }\n }\n }\n if (level > 0) {\n return -2;\n }\n\n return -1;\n}\n\nexport function expandTabs(line: string, indent = 0) {\n let col = indent;\n let expanded = '';\n for (const char of line) {\n if (char === '\\t') {\n const added = 4 - (col % 4);\n expanded += ' '.repeat(added);\n col += added;\n } else {\n expanded += char;\n col++;\n }\n }\n\n return expanded;\n}\n", "import { _defaults } from './defaults.ts';\nimport {\n rtrim,\n splitCells,\n findClosingBracket,\n expandTabs,\n trimTrailingBlankLines,\n} from './helpers.ts';\nimport type { Rules } from './rules.ts';\nimport type { _Lexer } from './Lexer.ts';\nimport type { Links, Tokens, Token } from './Tokens.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\n\nfunction outputLink(cap: string[], link: Pick, raw: string, lexer: _Lexer, rules: Rules): Tokens.Link | Tokens.Image {\n const href = link.href;\n const title = link.title || null;\n const text = cap[1].replace(rules.other.outputLinkReplace, '$1');\n\n lexer.state.inLink = true;\n const token: Tokens.Link | Tokens.Image = {\n type: cap[0].charAt(0) === '!' ? 'image' : 'link',\n raw,\n href,\n title,\n text,\n tokens: lexer.inlineTokens(text),\n };\n lexer.state.inLink = false;\n return token;\n}\n\nfunction indentCodeCompensation(raw: string, text: string, rules: Rules) {\n const matchIndentToCode = raw.match(rules.other.indentCodeCompensation);\n\n if (matchIndentToCode === null) {\n return text;\n }\n\n const indentToCode = matchIndentToCode[1];\n\n return text\n .split('\\n')\n .map(node => {\n const matchIndentInNode = node.match(rules.other.beginningSpace);\n if (matchIndentInNode === null) {\n return node;\n }\n\n const [indentInNode] = matchIndentInNode;\n\n if (indentInNode.length >= indentToCode.length) {\n return node.slice(indentToCode.length);\n }\n\n return node;\n })\n .join('\\n');\n}\n\n/**\n * Tokenizer\n */\nexport class _Tokenizer {\n options: MarkedOptions;\n rules!: Rules; // set by the lexer\n lexer!: _Lexer; // set by the lexer\n\n constructor(options?: MarkedOptions) {\n this.options = options || _defaults;\n }\n\n space(src: string): Tokens.Space | undefined {\n const cap = this.rules.block.newline.exec(src);\n if (cap && cap[0].length > 0) {\n return {\n type: 'space',\n raw: cap[0],\n };\n }\n }\n\n code(src: string): Tokens.Code | undefined {\n const cap = this.rules.block.code.exec(src);\n if (cap) {\n const raw = this.options.pedantic\n ? cap[0]\n : trimTrailingBlankLines(cap[0]);\n const text = raw.replace(this.rules.other.codeRemoveIndent, '');\n return {\n type: 'code',\n raw,\n codeBlockStyle: 'indented',\n text,\n };\n }\n }\n\n fences(src: string): Tokens.Code | undefined {\n const cap = this.rules.block.fences.exec(src);\n if (cap) {\n const raw = cap[0];\n const text = indentCodeCompensation(raw, cap[3] || '', this.rules);\n\n return {\n type: 'code',\n raw,\n lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, '$1') : cap[2],\n text,\n };\n }\n }\n\n heading(src: string): Tokens.Heading | undefined {\n const cap = this.rules.block.heading.exec(src);\n if (cap) {\n let text = cap[2].trim();\n\n // remove trailing #s\n if (this.rules.other.endingHash.test(text)) {\n const trimmed = rtrim(text, '#');\n if (this.options.pedantic) {\n text = trimmed.trim();\n } else if (!trimmed || this.rules.other.endingSpaceChar.test(trimmed)) {\n // CommonMark requires space before trailing #s\n text = trimmed.trim();\n }\n }\n\n return {\n type: 'heading',\n raw: rtrim(cap[0], '\\n'),\n depth: cap[1].length,\n text,\n tokens: this.lexer.inline(text),\n };\n }\n }\n\n hr(src: string): Tokens.Hr | undefined {\n const cap = this.rules.block.hr.exec(src);\n if (cap) {\n return {\n type: 'hr',\n raw: rtrim(cap[0], '\\n'),\n };\n }\n }\n\n blockquote(src: string): Tokens.Blockquote | undefined {\n const cap = this.rules.block.blockquote.exec(src);\n if (cap) {\n let lines = rtrim(cap[0], '\\n').split('\\n');\n let raw = '';\n let text = '';\n const tokens: Token[] = [];\n\n while (lines.length > 0) {\n let inBlockquote = false;\n const currentLines = [];\n\n let i;\n for (i = 0; i < lines.length; i++) {\n // get lines up to a continuation\n if (this.rules.other.blockquoteStart.test(lines[i])) {\n currentLines.push(lines[i]);\n inBlockquote = true;\n } else if (!inBlockquote) {\n currentLines.push(lines[i]);\n } else {\n break;\n }\n }\n lines = lines.slice(i);\n\n const currentRaw = currentLines.join('\\n');\n const currentText = currentRaw\n // precede setext continuation with 4 spaces so it isn't a setext\n .replace(this.rules.other.blockquoteSetextReplace, '\\n $1')\n .replace(this.rules.other.blockquoteSetextReplace2, '');\n raw = raw ? `${raw}\\n${currentRaw}` : currentRaw;\n text = text ? `${text}\\n${currentText}` : currentText;\n\n // parse blockquote lines as top level tokens\n // merge paragraphs if this is a continuation\n const top = this.lexer.state.top;\n this.lexer.state.top = true;\n this.lexer.blockTokens(currentText, tokens, true);\n this.lexer.state.top = top;\n\n // if there is no continuation then we are done\n if (lines.length === 0) {\n break;\n }\n\n const lastToken = tokens.at(-1);\n\n if (lastToken?.type === 'code') {\n // blockquote continuation cannot be preceded by a code block\n break;\n } else if (lastToken?.type === 'blockquote') {\n // include continuation in nested blockquote\n const oldToken = lastToken as Tokens.Blockquote;\n const newText = oldToken.raw + '\\n' + lines.join('\\n');\n const newToken = this.blockquote(newText)!;\n tokens[tokens.length - 1] = newToken;\n\n raw = raw.substring(0, raw.length - oldToken.raw.length) + newToken.raw;\n text = text.substring(0, text.length - oldToken.text.length) + newToken.text;\n break;\n } else if (lastToken?.type === 'list') {\n // include continuation in nested list\n const oldToken = lastToken as Tokens.List;\n const newText = oldToken.raw + '\\n' + lines.join('\\n');\n const newToken = this.list(newText)!;\n tokens[tokens.length - 1] = newToken;\n\n raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;\n text = text.substring(0, text.length - oldToken.raw.length) + newToken.raw;\n lines = newText.substring(tokens.at(-1)!.raw.length).split('\\n');\n continue;\n }\n }\n\n return {\n type: 'blockquote',\n raw,\n tokens,\n text,\n };\n }\n }\n\n list(src: string): Tokens.List | undefined {\n let cap = this.rules.block.list.exec(src);\n if (cap) {\n let bull = cap[1].trim();\n const isordered = bull.length > 1;\n\n const list: Tokens.List = {\n type: 'list',\n raw: '',\n ordered: isordered,\n start: isordered ? +bull.slice(0, -1) : '',\n loose: false,\n items: [],\n };\n\n bull = isordered ? `\\\\d{1,9}\\\\${bull.slice(-1)}` : `\\\\${bull}`;\n\n if (this.options.pedantic) {\n bull = isordered ? bull : '[*+-]';\n }\n\n // Get next list item\n const itemRegex = this.rules.other.listItemRegex(bull);\n let endsWithBlankLine = false;\n // Check if current bullet point can start a new List Item\n while (src) {\n let endEarly = false;\n let raw = '';\n let itemContents = '';\n if (!(cap = itemRegex.exec(src))) {\n break;\n }\n\n if (this.rules.block.hr.test(src)) { // End list if bullet was actually HR (possibly move into itemRegex?)\n break;\n }\n\n raw = cap[0];\n src = src.substring(raw.length);\n\n let line = expandTabs(cap[2].split('\\n', 1)[0], cap[1].length);\n let nextLine = src.split('\\n', 1)[0];\n let blankLine = !line.trim();\n\n let indent = 0;\n if (this.options.pedantic) {\n indent = 2;\n itemContents = line.trimStart();\n } else if (blankLine) {\n indent = cap[1].length + 1;\n } else {\n indent = line.search(this.rules.other.nonSpaceChar); // Find first non-space char\n indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent\n itemContents = line.slice(indent);\n indent += cap[1].length;\n }\n\n if (blankLine && this.rules.other.blankLine.test(nextLine)) { // Items begin with at most one blank line\n raw += nextLine + '\\n';\n src = src.substring(nextLine.length + 1);\n endEarly = true;\n }\n\n if (!endEarly) {\n const nextBulletRegex = this.rules.other.nextBulletRegex(indent);\n const hrRegex = this.rules.other.hrRegex(indent);\n const fencesBeginRegex = this.rules.other.fencesBeginRegex(indent);\n const headingBeginRegex = this.rules.other.headingBeginRegex(indent);\n const htmlBeginRegex = this.rules.other.htmlBeginRegex(indent);\n const blockquoteBeginRegex = this.rules.other.blockquoteBeginRegex(indent);\n\n // Check if following lines should be included in List Item\n while (src) {\n const rawLine = src.split('\\n', 1)[0];\n let nextLineWithoutTabs;\n nextLine = rawLine;\n\n // Re-align to follow commonmark nesting rules\n if (this.options.pedantic) {\n nextLine = nextLine.replace(this.rules.other.listReplaceNesting, ' ');\n nextLineWithoutTabs = nextLine;\n } else {\n nextLineWithoutTabs = nextLine.replace(this.rules.other.tabCharGlobal, ' ');\n }\n\n // End list item if found code fences\n if (fencesBeginRegex.test(nextLine)) {\n break;\n }\n\n // End list item if found start of new heading\n if (headingBeginRegex.test(nextLine)) {\n break;\n }\n\n // End list item if found start of html block\n if (htmlBeginRegex.test(nextLine)) {\n break;\n }\n\n // End list item if found start of blockquote\n if (blockquoteBeginRegex.test(nextLine)) {\n break;\n }\n\n // End list item if found start of new bullet\n if (nextBulletRegex.test(nextLine)) {\n break;\n }\n\n // Horizontal rule found\n if (hrRegex.test(nextLine)) {\n break;\n }\n\n if (nextLineWithoutTabs.search(this.rules.other.nonSpaceChar) >= indent || !nextLine.trim()) { // Dedent if possible\n itemContents += '\\n' + nextLineWithoutTabs.slice(indent);\n } else {\n // not enough indentation\n if (blankLine) {\n break;\n }\n\n // paragraph continuation unless last line was a different block level element\n if (line.replace(this.rules.other.tabCharGlobal, ' ').search(this.rules.other.nonSpaceChar) >= 4) { // indented code block\n break;\n }\n if (fencesBeginRegex.test(line)) {\n break;\n }\n if (headingBeginRegex.test(line)) {\n break;\n }\n if (hrRegex.test(line)) {\n break;\n }\n\n itemContents += '\\n' + nextLine;\n }\n\n blankLine = !nextLine.trim();\n\n raw += rawLine + '\\n';\n src = src.substring(rawLine.length + 1);\n line = nextLineWithoutTabs.slice(indent);\n }\n }\n\n if (!list.loose) {\n // If the previous item ended with a blank line, the list is loose\n if (endsWithBlankLine) {\n list.loose = true;\n } else if (this.rules.other.doubleBlankLine.test(raw)) {\n endsWithBlankLine = true;\n }\n }\n\n list.items.push({\n type: 'list_item',\n raw,\n task: !!this.options.gfm && this.rules.other.listIsTask.test(itemContents),\n loose: false,\n text: itemContents,\n tokens: [],\n });\n\n list.raw += raw;\n }\n\n // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic\n const lastItem = list.items.at(-1);\n if (lastItem) {\n lastItem.raw = lastItem.raw.trimEnd();\n lastItem.text = lastItem.text.trimEnd();\n } else {\n // not a list since there were no items\n return;\n }\n list.raw = list.raw.trimEnd();\n\n // Item child tokens handled here at end because we needed to have the final item to trim it first\n for (const item of list.items) {\n this.lexer.state.top = false;\n item.tokens = this.lexer.blockTokens(item.text, []);\n const itemToken = item.tokens[0];\n if (item.task && (itemToken?.type === 'text' || itemToken?.type === 'paragraph')) {\n // Remove checkbox markdown from item tokens\n item.text = item.text.replace(this.rules.other.listReplaceTask, '');\n itemToken.raw = itemToken.raw.replace(this.rules.other.listReplaceTask, '');\n itemToken.text = itemToken.text.replace(this.rules.other.listReplaceTask, '');\n for (let i = this.lexer.inlineQueue.length - 1; i >= 0; i--) {\n if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[i].src)) {\n this.lexer.inlineQueue[i].src = this.lexer.inlineQueue[i].src.replace(this.rules.other.listReplaceTask, '');\n break;\n }\n }\n\n const taskRaw = this.rules.other.listTaskCheckbox.exec(item.raw);\n if (taskRaw) {\n const checkboxToken: Tokens.Checkbox = {\n type: 'checkbox',\n raw: taskRaw[0] + ' ',\n checked: taskRaw[0] !== '[ ]',\n };\n item.checked = checkboxToken.checked;\n if (list.loose) {\n if (item.tokens[0] && ['paragraph', 'text'].includes(item.tokens[0].type) && 'tokens' in item.tokens[0] && item.tokens[0].tokens) {\n item.tokens[0].raw = checkboxToken.raw + item.tokens[0].raw;\n item.tokens[0].text = checkboxToken.raw + item.tokens[0].text;\n item.tokens[0].tokens.unshift(checkboxToken);\n } else {\n item.tokens.unshift({\n type: 'paragraph',\n raw: checkboxToken.raw,\n text: checkboxToken.raw,\n tokens: [checkboxToken],\n });\n }\n } else {\n item.tokens.unshift(checkboxToken);\n }\n }\n } else if (item.task) {\n item.task = false;\n }\n\n if (!list.loose) {\n // Check if list should be loose\n const spacers = item.tokens.filter(t => t.type === 'space');\n const hasMultipleLineBreaks = spacers.length > 0 && spacers.some(t => this.rules.other.anyLine.test(t.raw));\n\n list.loose = hasMultipleLineBreaks;\n }\n }\n\n // Set all items to loose if list is loose\n if (list.loose) {\n for (const item of list.items) {\n item.loose = true;\n for (const token of item.tokens) {\n if (token.type === 'text') {\n token.type = 'paragraph';\n }\n }\n }\n }\n\n return list;\n }\n }\n\n html(src: string): Tokens.HTML | undefined {\n const cap = this.rules.block.html.exec(src);\n if (cap) {\n const raw = trimTrailingBlankLines(cap[0]);\n const token: Tokens.HTML = {\n type: 'html',\n block: true,\n raw,\n pre: cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style',\n text: raw,\n };\n return token;\n }\n }\n\n def(src: string): Tokens.Def | undefined {\n const cap = this.rules.block.def.exec(src);\n if (cap) {\n const tag = cap[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, ' ');\n const href = cap[2] ? cap[2].replace(this.rules.other.hrefBrackets, '$1').replace(this.rules.inline.anyPunctuation, '$1') : '';\n const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, '$1') : cap[3];\n return {\n type: 'def',\n tag,\n raw: rtrim(cap[0], '\\n'),\n href,\n title,\n };\n }\n }\n\n table(src: string): Tokens.Table | undefined {\n const cap = this.rules.block.table.exec(src);\n if (!cap) {\n return;\n }\n\n if (!this.rules.other.tableDelimiter.test(cap[2])) {\n // delimiter row must have a pipe (|) or colon (:) otherwise it is a setext heading\n return;\n }\n\n const headers = splitCells(cap[1]);\n const aligns = cap[2].replace(this.rules.other.tableAlignChars, '').split('|');\n const rows = cap[3]?.trim() ? cap[3].replace(this.rules.other.tableRowBlankLine, '').split('\\n') : [];\n\n const item: Tokens.Table = {\n type: 'table',\n raw: rtrim(cap[0], '\\n'),\n header: [],\n align: [],\n rows: [],\n };\n\n if (headers.length !== aligns.length) {\n // header and align columns must be equal, rows can be different.\n return;\n }\n\n for (const align of aligns) {\n if (this.rules.other.tableAlignRight.test(align)) {\n item.align.push('right');\n } else if (this.rules.other.tableAlignCenter.test(align)) {\n item.align.push('center');\n } else if (this.rules.other.tableAlignLeft.test(align)) {\n item.align.push('left');\n } else {\n item.align.push(null);\n }\n }\n\n for (let i = 0; i < headers.length; i++) {\n item.header.push({\n text: headers[i],\n tokens: this.lexer.inline(headers[i]),\n header: true,\n align: item.align[i],\n });\n }\n\n for (const row of rows) {\n item.rows.push(splitCells(row, item.header.length).map((cell, i) => {\n return {\n text: cell,\n tokens: this.lexer.inline(cell),\n header: false,\n align: item.align[i],\n };\n }));\n }\n\n return item;\n }\n\n lheading(src: string): Tokens.Heading | undefined {\n const cap = this.rules.block.lheading.exec(src);\n if (cap) {\n const text = cap[1].trim();\n return {\n type: 'heading',\n raw: rtrim(cap[0], '\\n'),\n depth: cap[2].charAt(0) === '=' ? 1 : 2,\n text,\n tokens: this.lexer.inline(text),\n };\n }\n }\n\n paragraph(src: string): Tokens.Paragraph | undefined {\n const cap = this.rules.block.paragraph.exec(src);\n if (cap) {\n const text = cap[1].charAt(cap[1].length - 1) === '\\n'\n ? cap[1].slice(0, -1)\n : cap[1];\n return {\n type: 'paragraph',\n raw: cap[0],\n text,\n tokens: this.lexer.inline(text),\n };\n }\n }\n\n text(src: string): Tokens.Text | undefined {\n const cap = this.rules.block.text.exec(src);\n if (cap) {\n return {\n type: 'text',\n raw: cap[0],\n text: cap[0],\n tokens: this.lexer.inline(cap[0]),\n };\n }\n }\n\n escape(src: string): Tokens.Escape | undefined {\n const cap = this.rules.inline.escape.exec(src);\n if (cap) {\n return {\n type: 'escape',\n raw: cap[0],\n text: cap[1],\n };\n }\n }\n\n tag(src: string): Tokens.Tag | undefined {\n const cap = this.rules.inline.tag.exec(src);\n if (cap) {\n if (!this.lexer.state.inLink && this.rules.other.startATag.test(cap[0])) {\n this.lexer.state.inLink = true;\n } else if (this.lexer.state.inLink && this.rules.other.endATag.test(cap[0])) {\n this.lexer.state.inLink = false;\n }\n if (!this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(cap[0])) {\n this.lexer.state.inRawBlock = true;\n } else if (this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(cap[0])) {\n this.lexer.state.inRawBlock = false;\n }\n\n return {\n type: 'html',\n raw: cap[0],\n inLink: this.lexer.state.inLink,\n inRawBlock: this.lexer.state.inRawBlock,\n block: false,\n text: cap[0],\n };\n }\n }\n\n link(src: string): Tokens.Link | Tokens.Image | undefined {\n const cap = this.rules.inline.link.exec(src);\n if (cap) {\n const trimmedUrl = cap[2].trim();\n if (!this.options.pedantic && this.rules.other.startAngleBracket.test(trimmedUrl)) {\n // commonmark requires matching angle brackets\n if (!(this.rules.other.endAngleBracket.test(trimmedUrl))) {\n return;\n }\n\n // ending angle bracket cannot be escaped\n const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\\\');\n if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {\n return;\n }\n } else {\n // find closing parenthesis\n const lastParenIndex = findClosingBracket(cap[2], '()');\n if (lastParenIndex === -2) {\n // more open parens than closed\n return;\n }\n\n if (lastParenIndex > -1) {\n const start = cap[0].indexOf('!') === 0 ? 5 : 4;\n const linkLen = start + cap[1].length + lastParenIndex;\n cap[2] = cap[2].substring(0, lastParenIndex);\n cap[0] = cap[0].substring(0, linkLen).trim();\n cap[3] = '';\n }\n }\n let href = cap[2];\n let title = '';\n if (this.options.pedantic) {\n // split pedantic href and title\n const link = this.rules.other.pedanticHrefTitle.exec(href);\n\n if (link) {\n href = link[1];\n title = link[3];\n }\n } else {\n title = cap[3] ? cap[3].slice(1, -1) : '';\n }\n\n href = href.trim();\n if (this.rules.other.startAngleBracket.test(href)) {\n if (this.options.pedantic && !(this.rules.other.endAngleBracket.test(trimmedUrl))) {\n // pedantic allows starting angle bracket without ending angle bracket\n href = href.slice(1);\n } else {\n href = href.slice(1, -1);\n }\n }\n return outputLink(cap, {\n href: href ? href.replace(this.rules.inline.anyPunctuation, '$1') : href,\n title: title ? title.replace(this.rules.inline.anyPunctuation, '$1') : title,\n }, cap[0], this.lexer, this.rules);\n }\n }\n\n reflink(src: string, links: Links): Tokens.Link | Tokens.Image | Tokens.Text | undefined {\n let cap;\n if ((cap = this.rules.inline.reflink.exec(src))\n || (cap = this.rules.inline.nolink.exec(src))) {\n const linkString = (cap[2] || cap[1]).replace(this.rules.other.multipleSpaceGlobal, ' ');\n const link = links[linkString.toLowerCase()];\n if (!link) {\n const text = cap[0].charAt(0);\n return {\n type: 'text',\n raw: text,\n text,\n };\n }\n return outputLink(cap, link, cap[0], this.lexer, this.rules);\n }\n }\n\n emStrong(src: string, maskedSrc: string, prevChar = ''): Tokens.Em | Tokens.Strong | undefined {\n let match = this.rules.inline.emStrongLDelim.exec(src);\n if (!match) return;\n if (!match[1] && !match[2] && !match[3] && !match[4]) return;\n\n // _ can't be between two alphanumerics. \\p{L}\\p{N} includes non-english alphabet/numbers as well\n if (match[4] && prevChar.match(this.rules.other.unicodeAlphaNumeric)) return;\n\n const nextChar = match[1] || match[3] || '';\n\n if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {\n // unicode Regex counts emoji as 1 char; spread into array for proper count (used multiple times below)\n const lLength = [...match[0]].length - 1;\n let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;\n\n const endReg = match[0][0] === '*' ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;\n endReg.lastIndex = 0;\n\n // Clip maskedSrc to same section of string as src (move to lexer?)\n maskedSrc = maskedSrc.slice(-1 * src.length + lLength);\n\n while ((match = endReg.exec(maskedSrc)) !== null) {\n rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];\n\n if (!rDelim) continue; // skip single * in __abc*abc__\n\n rLength = [...rDelim].length;\n\n if (match[3] || match[4]) { // found another Left Delim\n delimTotal += rLength;\n continue;\n } else if (match[5] || match[6]) { // either Left or Right Delim\n if (lLength % 3 && !((lLength + rLength) % 3)) {\n midDelimTotal += rLength;\n continue; // CommonMark Emphasis Rules 9-10\n }\n }\n\n delimTotal -= rLength;\n\n if (delimTotal > 0) continue; // Haven't found enough closing delimiters\n\n // Remove extra characters. *a*** -> *a*\n rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);\n // char length can be >1 for unicode characters;\n const lastCharLength = [...match[0]][0].length;\n const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);\n\n // Create `em` if smallest delimiter has odd char count. *a***\n if (Math.min(lLength, rLength) % 2) {\n const text = raw.slice(1, -1);\n return {\n type: 'em',\n raw,\n text,\n tokens: this.lexer.inlineTokens(text),\n };\n }\n\n // Create 'strong' if smallest delimiter has even char count. **a***\n const text = raw.slice(2, -2);\n return {\n type: 'strong',\n raw,\n text,\n tokens: this.lexer.inlineTokens(text),\n };\n }\n }\n }\n\n codespan(src: string): Tokens.Codespan | undefined {\n const cap = this.rules.inline.code.exec(src);\n if (cap) {\n let text = cap[2].replace(this.rules.other.newLineCharGlobal, ' ');\n const hasNonSpaceChars = this.rules.other.nonSpaceChar.test(text);\n const hasSpaceCharsOnBothEnds = this.rules.other.startingSpaceChar.test(text) && this.rules.other.endingSpaceChar.test(text);\n if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {\n text = text.substring(1, text.length - 1);\n }\n return {\n type: 'codespan',\n raw: cap[0],\n text,\n };\n }\n }\n\n br(src: string): Tokens.Br | undefined {\n const cap = this.rules.inline.br.exec(src);\n if (cap) {\n return {\n type: 'br',\n raw: cap[0],\n };\n }\n }\n\n del(src: string, maskedSrc: string, prevChar = ''): Tokens.Del | undefined {\n let match = this.rules.inline.delLDelim.exec(src);\n if (!match) return;\n\n const nextChar = match[1] || '';\n\n if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {\n // unicode Regex counts emoji as 1 char; spread into array for proper count\n const lLength = [...match[0]].length - 1;\n let rDelim, rLength, delimTotal = lLength;\n\n const endReg = this.rules.inline.delRDelim;\n endReg.lastIndex = 0;\n\n // Clip maskedSrc to same section of string as src\n maskedSrc = maskedSrc.slice(-1 * src.length + lLength);\n\n while ((match = endReg.exec(maskedSrc)) !== null) {\n rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];\n\n if (!rDelim) continue;\n\n rLength = [...rDelim].length;\n\n if (rLength !== lLength) continue;\n\n if (match[3] || match[4]) { // found another Left Delim\n delimTotal += rLength;\n continue;\n }\n\n delimTotal -= rLength;\n\n if (delimTotal > 0) continue; // Haven't found enough closing delimiters\n\n // Remove extra characters\n rLength = Math.min(rLength, rLength + delimTotal);\n // char length can be >1 for unicode characters\n const lastCharLength = [...match[0]][0].length;\n const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);\n\n // Create del token - only single ~ or double ~~ supported\n const text = raw.slice(lLength, -lLength);\n return {\n type: 'del',\n raw,\n text,\n tokens: this.lexer.inlineTokens(text),\n };\n }\n }\n }\n\n autolink(src: string): Tokens.Link | undefined {\n const cap = this.rules.inline.autolink.exec(src);\n if (cap) {\n let text, href;\n if (cap[2] === '@') {\n text = cap[1];\n href = 'mailto:' + text;\n } else {\n text = cap[1];\n href = text;\n }\n\n return {\n type: 'link',\n raw: cap[0],\n text,\n href,\n tokens: [\n {\n type: 'text',\n raw: text,\n text,\n },\n ],\n };\n }\n }\n\n url(src: string): Tokens.Link | undefined {\n let cap;\n if (cap = this.rules.inline.url.exec(src)) {\n let text, href;\n if (cap[2] === '@') {\n text = cap[0];\n href = 'mailto:' + text;\n } else {\n // do extended autolink path validation\n let prevCapZero;\n do {\n prevCapZero = cap[0];\n cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? '';\n } while (prevCapZero !== cap[0]);\n text = cap[0];\n if (cap[1] === 'www.') {\n href = 'http://' + cap[0];\n } else {\n href = cap[0];\n }\n }\n return {\n type: 'link',\n raw: cap[0],\n text,\n href,\n tokens: [\n {\n type: 'text',\n raw: text,\n text,\n },\n ],\n };\n }\n }\n\n inlineText(src: string): Tokens.Text | undefined {\n const cap = this.rules.inline.text.exec(src);\n if (cap) {\n const escaped = this.lexer.state.inRawBlock;\n return {\n type: 'text',\n raw: cap[0],\n text: cap[0],\n escaped,\n };\n }\n }\n}\n", "import { _Tokenizer } from './Tokenizer.ts';\nimport { _defaults } from './defaults.ts';\nimport { other, block, inline } from './rules.ts';\nimport type { Token, TokensList, Tokens } from './Tokens.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\n\n/**\n * Block Lexer\n */\nexport class _Lexer {\n tokens: TokensList;\n options: MarkedOptions;\n state: {\n inLink: boolean;\n inRawBlock: boolean;\n top: boolean;\n };\n\n public inlineQueue: { src: string, tokens: Token[] }[];\n\n private tokenizer: _Tokenizer;\n\n constructor(options?: MarkedOptions) {\n // TokenList cannot be created in one go\n this.tokens = [] as unknown as TokensList;\n this.tokens.links = Object.create(null);\n this.options = options || _defaults;\n this.options.tokenizer = this.options.tokenizer || new _Tokenizer();\n this.tokenizer = this.options.tokenizer;\n this.tokenizer.options = this.options;\n this.tokenizer.lexer = this;\n this.inlineQueue = [];\n this.state = {\n inLink: false,\n inRawBlock: false,\n top: true,\n };\n\n const rules = {\n other,\n block: block.normal,\n inline: inline.normal,\n };\n\n if (this.options.pedantic) {\n rules.block = block.pedantic;\n rules.inline = inline.pedantic;\n } else if (this.options.gfm) {\n rules.block = block.gfm;\n if (this.options.breaks) {\n rules.inline = inline.breaks;\n } else {\n rules.inline = inline.gfm;\n }\n }\n this.tokenizer.rules = rules;\n }\n\n /**\n * Expose Rules\n */\n static get rules() {\n return {\n block,\n inline,\n };\n }\n\n /**\n * Static Lex Method\n */\n static lex(src: string, options?: MarkedOptions) {\n const lexer = new _Lexer(options);\n return lexer.lex(src);\n }\n\n /**\n * Static Lex Inline Method\n */\n static lexInline(src: string, options?: MarkedOptions) {\n const lexer = new _Lexer(options);\n return lexer.inlineTokens(src);\n }\n\n /**\n * Preprocessing\n */\n lex(src: string) {\n src = src.replace(other.carriageReturn, '\\n');\n\n this.blockTokens(src, this.tokens);\n\n for (let i = 0; i < this.inlineQueue.length; i++) {\n const next = this.inlineQueue[i];\n this.inlineTokens(next.src, next.tokens);\n }\n this.inlineQueue = [];\n\n return this.tokens;\n }\n\n /**\n * Lexing\n */\n blockTokens(src: string, tokens?: Token[], lastParagraphClipped?: boolean): Token[];\n blockTokens(src: string, tokens?: TokensList, lastParagraphClipped?: boolean): TokensList;\n blockTokens(src: string, tokens: Token[] = [], lastParagraphClipped = false) {\n this.tokenizer.lexer = this;\n if (this.options.pedantic) {\n src = src.replace(other.tabCharGlobal, ' ').replace(other.spaceLine, '');\n }\n\n let srcLength = Infinity;\n while (src) {\n if (src.length < srcLength) {\n srcLength = src.length;\n } else {\n this.infiniteLoopError(src.charCodeAt(0));\n break;\n }\n\n let token: Tokens.Generic | undefined;\n\n if (this.options.extensions?.block?.some((extTokenizer) => {\n if (token = extTokenizer.call({ lexer: this }, src, tokens)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n return true;\n }\n return false;\n })) {\n continue;\n }\n\n // newline\n if (token = this.tokenizer.space(src)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n if (token.raw.length === 1 && lastToken !== undefined) {\n // if there's a single \\n as a spacer, it's terminating the last line,\n // so move it there so that we don't get unnecessary paragraph tags\n lastToken.raw += '\\n';\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n // code\n if (token = this.tokenizer.code(src)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n // An indented code block cannot interrupt a paragraph.\n if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {\n lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n lastToken.text += '\\n' + token.text;\n this.inlineQueue.at(-1)!.src = lastToken.text;\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n // fences\n if (token = this.tokenizer.fences(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // heading\n if (token = this.tokenizer.heading(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // hr\n if (token = this.tokenizer.hr(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // blockquote\n if (token = this.tokenizer.blockquote(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // list\n if (token = this.tokenizer.list(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // html\n if (token = this.tokenizer.html(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // def\n if (token = this.tokenizer.def(src)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {\n lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n lastToken.text += '\\n' + token.raw;\n this.inlineQueue.at(-1)!.src = lastToken.text;\n } else if (!this.tokens.links[token.tag]) {\n this.tokens.links[token.tag] = {\n href: token.href,\n title: token.title,\n };\n tokens.push(token);\n }\n continue;\n }\n\n // table (gfm)\n if (token = this.tokenizer.table(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // lheading\n if (token = this.tokenizer.lheading(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // top-level paragraph\n // prevent paragraph consuming extensions by clipping 'src' to extension start\n let cutSrc = src;\n if (this.options.extensions?.startBlock) {\n let startIndex = Infinity;\n const tempSrc = src.slice(1);\n let tempStart;\n this.options.extensions.startBlock.forEach((getStartIndex) => {\n tempStart = getStartIndex.call({ lexer: this }, tempSrc);\n if (typeof tempStart === 'number' && tempStart >= 0) {\n startIndex = Math.min(startIndex, tempStart);\n }\n });\n if (startIndex < Infinity && startIndex >= 0) {\n cutSrc = src.substring(0, startIndex + 1);\n }\n }\n if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {\n const lastToken = tokens.at(-1);\n if (lastParagraphClipped && lastToken?.type === 'paragraph') {\n lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n lastToken.text += '\\n' + token.text;\n this.inlineQueue.pop();\n this.inlineQueue.at(-1)!.src = lastToken.text;\n } else {\n tokens.push(token);\n }\n lastParagraphClipped = cutSrc.length !== src.length;\n src = src.substring(token.raw.length);\n continue;\n }\n\n // text\n if (token = this.tokenizer.text(src)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n if (lastToken?.type === 'text') {\n lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n lastToken.text += '\\n' + token.text;\n this.inlineQueue.pop();\n this.inlineQueue.at(-1)!.src = lastToken.text;\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n if (src) {\n this.infiniteLoopError(src.charCodeAt(0));\n break;\n }\n }\n\n this.state.top = true;\n return tokens;\n }\n\n inline(src: string, tokens: Token[] = []) {\n this.inlineQueue.push({ src, tokens });\n return tokens;\n }\n\n /**\n * Lexing/Compiling\n */\n inlineTokens(src: string, tokens: Token[] = []): Token[] {\n this.tokenizer.lexer = this;\n // String with links masked to avoid interference with em and strong\n let maskedSrc = src;\n let match: RegExpExecArray | null = null;\n\n // Mask out reflinks\n if (this.tokens.links) {\n const links = Object.keys(this.tokens.links);\n if (links.length > 0) {\n while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) !== null) {\n if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {\n maskedSrc = maskedSrc.slice(0, match.index)\n + '[' + 'a'.repeat(match[0].length - 2) + ']'\n + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);\n }\n }\n }\n }\n\n // Mask out escaped characters\n while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) !== null) {\n maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);\n }\n\n // Mask out other blocks\n let offset;\n while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) !== null) {\n offset = match[2] ? match[2].length : 0;\n maskedSrc = maskedSrc.slice(0, match.index + offset) + '[' + 'a'.repeat(match[0].length - offset - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);\n }\n\n // Mask out blocks from extensions\n maskedSrc = this.options.hooks?.emStrongMask?.call({ lexer: this }, maskedSrc) ?? maskedSrc;\n\n let keepPrevChar = false;\n let prevChar = '';\n let srcLength = Infinity;\n while (src) {\n if (src.length < srcLength) {\n srcLength = src.length;\n } else {\n this.infiniteLoopError(src.charCodeAt(0));\n break;\n }\n\n if (!keepPrevChar) {\n prevChar = '';\n }\n keepPrevChar = false;\n\n let token: Tokens.Generic | undefined;\n\n // extensions\n if (this.options.extensions?.inline?.some((extTokenizer) => {\n if (token = extTokenizer.call({ lexer: this }, src, tokens)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n return true;\n }\n return false;\n })) {\n continue;\n }\n\n // escape\n if (token = this.tokenizer.escape(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // tag\n if (token = this.tokenizer.tag(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // link\n if (token = this.tokenizer.link(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // reflink, nolink\n if (token = this.tokenizer.reflink(src, this.tokens.links)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n if (token.type === 'text' && lastToken?.type === 'text') {\n lastToken.raw += token.raw;\n lastToken.text += token.text;\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n // em & strong\n if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // code\n if (token = this.tokenizer.codespan(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // br\n if (token = this.tokenizer.br(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // del (gfm)\n if (token = this.tokenizer.del(src, maskedSrc, prevChar)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // autolink\n if (token = this.tokenizer.autolink(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // url (gfm)\n if (!this.state.inLink && (token = this.tokenizer.url(src))) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // text\n // prevent inlineText consuming extensions by clipping 'src' to extension start\n let cutSrc = src;\n if (this.options.extensions?.startInline) {\n let startIndex = Infinity;\n const tempSrc = src.slice(1);\n let tempStart;\n this.options.extensions.startInline.forEach((getStartIndex) => {\n tempStart = getStartIndex.call({ lexer: this }, tempSrc);\n if (typeof tempStart === 'number' && tempStart >= 0) {\n startIndex = Math.min(startIndex, tempStart);\n }\n });\n if (startIndex < Infinity && startIndex >= 0) {\n cutSrc = src.substring(0, startIndex + 1);\n }\n }\n if (token = this.tokenizer.inlineText(cutSrc)) {\n src = src.substring(token.raw.length);\n if (token.raw.slice(-1) !== '_') { // Track prevChar before string of ____ started\n prevChar = token.raw.slice(-1);\n }\n keepPrevChar = true;\n const lastToken = tokens.at(-1);\n if (lastToken?.type === 'text') {\n lastToken.raw += token.raw;\n lastToken.text += token.text;\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n if (src) {\n this.infiniteLoopError(src.charCodeAt(0));\n break;\n }\n }\n\n return tokens;\n }\n\n private infiniteLoopError(byte: number) {\n const errMsg = 'Infinite loop on byte: ' + byte;\n if (this.options.silent) {\n console.error(errMsg);\n } else {\n throw new Error(errMsg);\n }\n }\n}\n", "import { _defaults } from './defaults.ts';\nimport {\n cleanUrl,\n escapeHtmlEntities,\n} from './helpers.ts';\nimport { other } from './rules.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\nimport type { Tokens } from './Tokens.ts';\nimport type { _Parser } from './Parser.ts';\n\n/**\n * Renderer\n */\nexport class _Renderer {\n options: MarkedOptions;\n parser!: _Parser; // set by the parser\n constructor(options?: MarkedOptions) {\n this.options = options || _defaults;\n }\n\n space(token: Tokens.Space): RendererOutput {\n return '' as RendererOutput;\n }\n\n code({ text, lang, escaped }: Tokens.Code): RendererOutput {\n const langString = (lang || '').match(other.notSpaceStart)?.[0];\n\n const code = text.replace(other.endingNewline, '') + '\\n';\n\n if (!langString) {\n return '
    '\n        + (escaped ? code : escapeHtmlEntities(code, true))\n        + '
    \\n' as RendererOutput;\n }\n\n return '
    '\n      + (escaped ? code : escapeHtmlEntities(code, true))\n      + '
    \\n' as RendererOutput;\n }\n\n blockquote({ tokens }: Tokens.Blockquote): RendererOutput {\n const body = this.parser.parse(tokens);\n return `
    \\n${body}
    \\n` as RendererOutput;\n }\n\n html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput {\n return text as RendererOutput;\n }\n\n def(token: Tokens.Def): RendererOutput {\n return '' as RendererOutput;\n }\n\n heading({ tokens, depth }: Tokens.Heading): RendererOutput {\n return `${this.parser.parseInline(tokens)}\\n` as RendererOutput;\n }\n\n hr(token: Tokens.Hr): RendererOutput {\n return '
    \\n' as RendererOutput;\n }\n\n list(token: Tokens.List): RendererOutput {\n const ordered = token.ordered;\n const start = token.start;\n\n let body = '';\n for (let j = 0; j < token.items.length; j++) {\n const item = token.items[j];\n body += this.listitem(item);\n }\n\n const type = ordered ? 'ol' : 'ul';\n const startAttr = (ordered && start !== 1) ? (' start=\"' + start + '\"') : '';\n return '<' + type + startAttr + '>\\n' + body + '\\n' as RendererOutput;\n }\n\n listitem(item: Tokens.ListItem): RendererOutput {\n return `
  • ${this.parser.parse(item.tokens)}
    • \\n` as RendererOutput;\n }\n\n checkbox({ checked }: Tokens.Checkbox): RendererOutput {\n return ' ' as RendererOutput;\n }\n\n paragraph({ tokens }: Tokens.Paragraph): RendererOutput {\n return `

    ${this.parser.parseInline(tokens)}

    \\n` as RendererOutput;\n }\n\n table(token: Tokens.Table): RendererOutput {\n let header = '';\n\n // header\n let cell = '';\n for (let j = 0; j < token.header.length; j++) {\n cell += this.tablecell(token.header[j]);\n }\n header += this.tablerow({ text: cell as ParserOutput });\n\n let body = '';\n for (let j = 0; j < token.rows.length; j++) {\n const row = token.rows[j];\n\n cell = '';\n for (let k = 0; k < row.length; k++) {\n cell += this.tablecell(row[k]);\n }\n\n body += this.tablerow({ text: cell as ParserOutput });\n }\n if (body) body = `${body}`;\n\n return '\\n'\n + '\\n'\n + header\n + '\\n'\n + body\n + '
    \\n' as RendererOutput;\n }\n\n tablerow({ text }: Tokens.TableRow): RendererOutput {\n return `\\n${text}\\n` as RendererOutput;\n }\n\n tablecell(token: Tokens.TableCell): RendererOutput {\n const content = this.parser.parseInline(token.tokens);\n const type = token.header ? 'th' : 'td';\n const tag = token.align\n ? `<${type} align=\"${token.align}\">`\n : `<${type}>`;\n return tag + content + `\\n` as RendererOutput;\n }\n\n /**\n * span level renderer\n */\n strong({ tokens }: Tokens.Strong): RendererOutput {\n return `${this.parser.parseInline(tokens)}` as RendererOutput;\n }\n\n em({ tokens }: Tokens.Em): RendererOutput {\n return `${this.parser.parseInline(tokens)}` as RendererOutput;\n }\n\n codespan({ text }: Tokens.Codespan): RendererOutput {\n return `${escapeHtmlEntities(text, true)}` as RendererOutput;\n }\n\n br(token: Tokens.Br): RendererOutput {\n return '
    ' as RendererOutput;\n }\n\n del({ tokens }: Tokens.Del): RendererOutput {\n return `${this.parser.parseInline(tokens)}` as RendererOutput;\n }\n\n link({ href, title, tokens }: Tokens.Link): RendererOutput {\n const text = this.parser.parseInline(tokens) as string;\n const cleanHref = cleanUrl(href);\n if (cleanHref === null) {\n return text as RendererOutput;\n }\n href = cleanHref;\n let out = '    ';\n return out as RendererOutput;\n }\n\n image({ href, title, text, tokens }: Tokens.Image): RendererOutput {\n if (tokens) {\n text = this.parser.parseInline(tokens, this.parser.textRenderer) as string;\n }\n const cleanHref = cleanUrl(href);\n if (cleanHref === null) {\n return escapeHtmlEntities(text) as RendererOutput;\n }\n href = cleanHref;\n\n let out = `\"${escapeHtmlEntities(text)}\"`;\n {\n // no need for block level renderers\n strong({ text }: Tokens.Strong): RendererOutput {\n return text as RendererOutput;\n }\n\n em({ text }: Tokens.Em): RendererOutput {\n return text as RendererOutput;\n }\n\n codespan({ text }: Tokens.Codespan): RendererOutput {\n return text as RendererOutput;\n }\n\n del({ text }: Tokens.Del): RendererOutput {\n return text as RendererOutput;\n }\n\n html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput {\n return text as RendererOutput;\n }\n\n text({ text }: Tokens.Text | Tokens.Escape | Tokens.Tag): RendererOutput {\n return text as RendererOutput;\n }\n\n link({ text }: Tokens.Link): RendererOutput {\n return '' + text as RendererOutput;\n }\n\n image({ text }: Tokens.Image): RendererOutput {\n return '' + text as RendererOutput;\n }\n\n br(): RendererOutput {\n return '' as RendererOutput;\n }\n\n checkbox({ raw }: Tokens.Checkbox): RendererOutput {\n return raw as RendererOutput;\n }\n}\n", "import { _Renderer } from './Renderer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { _defaults } from './defaults.ts';\nimport type { MarkedToken, Token, Tokens } from './Tokens.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\n\n/**\n * Parsing & Compiling\n */\nexport class _Parser {\n options: MarkedOptions;\n renderer: _Renderer;\n textRenderer: _TextRenderer;\n constructor(options?: MarkedOptions) {\n this.options = options || _defaults;\n this.options.renderer = this.options.renderer || new _Renderer();\n this.renderer = this.options.renderer;\n this.renderer.options = this.options;\n this.renderer.parser = this;\n this.textRenderer = new _TextRenderer();\n }\n\n /**\n * Static Parse Method\n */\n static parse(tokens: Token[], options?: MarkedOptions) {\n const parser = new _Parser(options);\n return parser.parse(tokens);\n }\n\n /**\n * Static Parse Inline Method\n */\n static parseInline(tokens: Token[], options?: MarkedOptions) {\n const parser = new _Parser(options);\n return parser.parseInline(tokens);\n }\n\n /**\n * Parse Loop\n */\n parse(tokens: Token[]): ParserOutput {\n this.renderer.parser = this;\n let out = '';\n\n for (let i = 0; i < tokens.length; i++) {\n const anyToken = tokens[i];\n\n // Run any renderer extensions\n if (this.options.extensions?.renderers?.[anyToken.type]) {\n const genericToken = anyToken as Tokens.Generic;\n const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);\n if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'def', 'paragraph', 'text'].includes(genericToken.type)) {\n out += ret || '';\n continue;\n }\n }\n\n const token = anyToken as MarkedToken;\n\n switch (token.type) {\n case 'space': {\n out += this.renderer.space(token);\n break;\n }\n case 'hr': {\n out += this.renderer.hr(token);\n break;\n }\n case 'heading': {\n out += this.renderer.heading(token);\n break;\n }\n case 'code': {\n out += this.renderer.code(token);\n break;\n }\n case 'table': {\n out += this.renderer.table(token);\n break;\n }\n case 'blockquote': {\n out += this.renderer.blockquote(token);\n break;\n }\n case 'list': {\n out += this.renderer.list(token);\n break;\n }\n case 'checkbox': {\n out += this.renderer.checkbox(token);\n break;\n }\n case 'html': {\n out += this.renderer.html(token);\n break;\n }\n case 'def': {\n out += this.renderer.def(token);\n break;\n }\n case 'paragraph': {\n out += this.renderer.paragraph(token);\n break;\n }\n case 'text': {\n out += this.renderer.text(token);\n break;\n }\n\n default: {\n const errMsg = 'Token with \"' + token.type + '\" type was not found.';\n if (this.options.silent) {\n console.error(errMsg);\n return '' as ParserOutput;\n } else {\n throw new Error(errMsg);\n }\n }\n }\n }\n\n return out as ParserOutput;\n }\n\n /**\n * Parse Inline Tokens\n */\n parseInline(tokens: Token[], renderer: _Renderer | _TextRenderer = this.renderer): ParserOutput {\n this.renderer.parser = this;\n let out = '';\n\n for (let i = 0; i < tokens.length; i++) {\n const anyToken = tokens[i];\n\n // Run any renderer extensions\n if (this.options.extensions?.renderers?.[anyToken.type]) {\n const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);\n if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(anyToken.type)) {\n out += ret || '';\n continue;\n }\n }\n\n const token = anyToken as MarkedToken;\n\n switch (token.type) {\n case 'escape': {\n out += renderer.text(token);\n break;\n }\n case 'html': {\n out += renderer.html(token);\n break;\n }\n case 'link': {\n out += renderer.link(token);\n break;\n }\n case 'image': {\n out += renderer.image(token);\n break;\n }\n case 'checkbox': {\n out += renderer.checkbox(token);\n break;\n }\n case 'strong': {\n out += renderer.strong(token);\n break;\n }\n case 'em': {\n out += renderer.em(token);\n break;\n }\n case 'codespan': {\n out += renderer.codespan(token);\n break;\n }\n case 'br': {\n out += renderer.br(token);\n break;\n }\n case 'del': {\n out += renderer.del(token);\n break;\n }\n case 'text': {\n out += renderer.text(token);\n break;\n }\n default: {\n const errMsg = 'Token with \"' + token.type + '\" type was not found.';\n if (this.options.silent) {\n console.error(errMsg);\n return '' as ParserOutput;\n } else {\n throw new Error(errMsg);\n }\n }\n }\n }\n return out as ParserOutput;\n }\n}\n", "import { _defaults } from './defaults.ts';\nimport { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\nimport type { Token, TokensList } from './Tokens.ts';\n\nexport class _Hooks {\n options: MarkedOptions;\n block?: boolean;\n\n constructor(options?: MarkedOptions) {\n this.options = options || _defaults;\n }\n\n static passThroughHooks = new Set([\n 'preprocess',\n 'postprocess',\n 'processAllTokens',\n 'emStrongMask',\n ]);\n\n static passThroughHooksRespectAsync = new Set([\n 'preprocess',\n 'postprocess',\n 'processAllTokens',\n ]);\n\n /**\n * Process markdown before marked\n */\n preprocess(markdown: string) {\n return markdown;\n }\n\n /**\n * Process HTML after marked is finished\n */\n postprocess(html: ParserOutput) {\n return html;\n }\n\n /**\n * Process all tokens before walk tokens\n */\n processAllTokens(tokens: Token[] | TokensList) {\n return tokens;\n }\n\n /**\n * Mask contents that should not be interpreted as em/strong delimiters\n */\n emStrongMask(src: string) {\n return src;\n }\n\n /**\n * Provide function to tokenize markdown\n */\n provideLexer(block = this.block) {\n return block ? _Lexer.lex : _Lexer.lexInline;\n }\n\n /**\n * Provide function to parse tokens\n */\n provideParser(block = this.block) {\n return block ? _Parser.parse : _Parser.parseInline;\n }\n}\n", "import { _getDefaults } from './defaults.ts';\nimport { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport { _Hooks } from './Hooks.ts';\nimport { _Renderer } from './Renderer.ts';\nimport { _Tokenizer } from './Tokenizer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { escapeHtmlEntities } from './helpers.ts';\nimport type { MarkedExtension, MarkedOptions } from './MarkedOptions.ts';\nimport type { Token, Tokens, TokensList } from './Tokens.ts';\n\nexport type MaybePromise = void | Promise;\n\ntype UnknownFunction = (...args: unknown[]) => unknown;\ntype GenericRendererFunction = (...args: unknown[]) => string | false;\n\nexport class Marked {\n defaults = _getDefaults();\n options = this.setOptions;\n\n parse = this.parseMarkdown(true);\n parseInline = this.parseMarkdown(false);\n\n Parser = _Parser;\n Renderer = _Renderer;\n TextRenderer = _TextRenderer;\n Lexer = _Lexer;\n Tokenizer = _Tokenizer;\n Hooks = _Hooks;\n\n constructor(...args: MarkedExtension[]) {\n this.use(...args);\n }\n\n /**\n * Run callback for every token\n */\n walkTokens(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) {\n let values: MaybePromise[] = [];\n for (const token of tokens) {\n values = values.concat(callback.call(this, token));\n switch (token.type) {\n case 'table': {\n const tableToken = token as Tokens.Table;\n for (const cell of tableToken.header) {\n values = values.concat(this.walkTokens(cell.tokens, callback));\n }\n for (const row of tableToken.rows) {\n for (const cell of row) {\n values = values.concat(this.walkTokens(cell.tokens, callback));\n }\n }\n break;\n }\n case 'list': {\n const listToken = token as Tokens.List;\n values = values.concat(this.walkTokens(listToken.items, callback));\n break;\n }\n default: {\n const genericToken = token as Tokens.Generic;\n if (this.defaults.extensions?.childTokens?.[genericToken.type]) {\n this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {\n const tokens = genericToken[childTokens].flat(Infinity) as Token[] | TokensList;\n values = values.concat(this.walkTokens(tokens, callback));\n });\n } else if (genericToken.tokens) {\n values = values.concat(this.walkTokens(genericToken.tokens, callback));\n }\n }\n }\n }\n return values;\n }\n\n use(...args: MarkedExtension[]) {\n const extensions: MarkedOptions['extensions'] = this.defaults.extensions || { renderers: {}, childTokens: {} };\n\n args.forEach((pack) => {\n // copy options to new object\n const opts = { ...pack } as MarkedOptions;\n\n // set async to true if it was set to true before\n opts.async = this.defaults.async || opts.async || false;\n\n // ==-- Parse \"addon\" extensions --== //\n if (pack.extensions) {\n pack.extensions.forEach((ext) => {\n if (!ext.name) {\n throw new Error('extension name required');\n }\n if ('renderer' in ext) { // Renderer extensions\n const prevRenderer = extensions.renderers[ext.name];\n if (prevRenderer) {\n // Replace extension with func to run new extension but fall back if false\n extensions.renderers[ext.name] = function(...args) {\n let ret = ext.renderer.apply(this, args);\n if (ret === false) {\n ret = prevRenderer.apply(this, args);\n }\n return ret;\n };\n } else {\n extensions.renderers[ext.name] = ext.renderer;\n }\n }\n if ('tokenizer' in ext) { // Tokenizer Extensions\n if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {\n throw new Error(\"extension level must be 'block' or 'inline'\");\n }\n const extLevel = extensions[ext.level];\n if (extLevel) {\n extLevel.unshift(ext.tokenizer);\n } else {\n extensions[ext.level] = [ext.tokenizer];\n }\n if (ext.start) { // Function to check for start of token\n if (ext.level === 'block') {\n if (extensions.startBlock) {\n extensions.startBlock.push(ext.start);\n } else {\n extensions.startBlock = [ext.start];\n }\n } else if (ext.level === 'inline') {\n if (extensions.startInline) {\n extensions.startInline.push(ext.start);\n } else {\n extensions.startInline = [ext.start];\n }\n }\n }\n }\n if ('childTokens' in ext && ext.childTokens) { // Child tokens to be visited by walkTokens\n extensions.childTokens[ext.name] = ext.childTokens;\n }\n });\n opts.extensions = extensions;\n }\n\n // ==-- Parse \"overwrite\" extensions --== //\n if (pack.renderer) {\n const renderer = this.defaults.renderer || new _Renderer(this.defaults);\n for (const prop in pack.renderer) {\n if (!(prop in renderer)) {\n throw new Error(`renderer '${prop}' does not exist`);\n }\n if (['options', 'parser'].includes(prop)) {\n // ignore options property\n continue;\n }\n const rendererProp = prop as Exclude, 'options' | 'parser'>;\n const rendererFunc = pack.renderer[rendererProp] as GenericRendererFunction;\n const prevRenderer = renderer[rendererProp] as GenericRendererFunction;\n // Replace renderer with func to run extension, but fall back if false\n renderer[rendererProp] = (...args: unknown[]) => {\n let ret = rendererFunc.apply(renderer, args);\n if (ret === false) {\n ret = prevRenderer.apply(renderer, args);\n }\n return (ret || '') as RendererOutput;\n };\n }\n opts.renderer = renderer;\n }\n if (pack.tokenizer) {\n const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);\n for (const prop in pack.tokenizer) {\n if (!(prop in tokenizer)) {\n throw new Error(`tokenizer '${prop}' does not exist`);\n }\n if (['options', 'rules', 'lexer'].includes(prop)) {\n // ignore options, rules, and lexer properties\n continue;\n }\n const tokenizerProp = prop as Exclude, 'options' | 'rules' | 'lexer'>;\n const tokenizerFunc = pack.tokenizer[tokenizerProp] as UnknownFunction;\n const prevTokenizer = tokenizer[tokenizerProp] as UnknownFunction;\n // Replace tokenizer with func to run extension, but fall back if false\n // @ts-expect-error cannot type tokenizer function dynamically\n tokenizer[tokenizerProp] = (...args: unknown[]) => {\n let ret = tokenizerFunc.apply(tokenizer, args);\n if (ret === false) {\n ret = prevTokenizer.apply(tokenizer, args);\n }\n return ret;\n };\n }\n opts.tokenizer = tokenizer;\n }\n\n // ==-- Parse Hooks extensions --== //\n if (pack.hooks) {\n const hooks = this.defaults.hooks || new _Hooks();\n for (const prop in pack.hooks) {\n if (!(prop in hooks)) {\n throw new Error(`hook '${prop}' does not exist`);\n }\n if (['options', 'block'].includes(prop)) {\n // ignore options and block properties\n continue;\n }\n const hooksProp = prop as Exclude, 'options' | 'block'>;\n const hooksFunc = pack.hooks[hooksProp] as UnknownFunction;\n const prevHook = hooks[hooksProp] as UnknownFunction;\n if (_Hooks.passThroughHooks.has(prop)) {\n // @ts-expect-error cannot type hook function dynamically\n hooks[hooksProp] = (arg: unknown) => {\n if (this.defaults.async && _Hooks.passThroughHooksRespectAsync.has(prop)) {\n return (async() => {\n const ret = await hooksFunc.call(hooks, arg);\n return prevHook.call(hooks, ret);\n })();\n }\n\n const ret = hooksFunc.call(hooks, arg);\n return prevHook.call(hooks, ret);\n };\n } else {\n // @ts-expect-error cannot type hook function dynamically\n hooks[hooksProp] = (...args: unknown[]) => {\n if (this.defaults.async) {\n return (async() => {\n let ret = await hooksFunc.apply(hooks, args);\n if (ret === false) {\n ret = await prevHook.apply(hooks, args);\n }\n return ret;\n })();\n }\n\n let ret = hooksFunc.apply(hooks, args);\n if (ret === false) {\n ret = prevHook.apply(hooks, args);\n }\n return ret;\n };\n }\n }\n opts.hooks = hooks;\n }\n\n // ==-- Parse WalkTokens extensions --== //\n if (pack.walkTokens) {\n const walkTokens = this.defaults.walkTokens;\n const packWalktokens = pack.walkTokens;\n opts.walkTokens = function(token) {\n let values: MaybePromise[] = [];\n values.push(packWalktokens.call(this, token));\n if (walkTokens) {\n values = values.concat(walkTokens.call(this, token));\n }\n return values;\n };\n }\n\n this.defaults = { ...this.defaults, ...opts };\n });\n\n return this;\n }\n\n setOptions(opt: MarkedOptions) {\n this.defaults = { ...this.defaults, ...opt };\n return this;\n }\n\n lexer(src: string, options?: MarkedOptions) {\n return _Lexer.lex(src, options ?? this.defaults);\n }\n\n parser(tokens: Token[], options?: MarkedOptions) {\n return _Parser.parse(tokens, options ?? this.defaults);\n }\n\n private parseMarkdown(blockType: boolean) {\n type overloadedParse = {\n (src: string, options: MarkedOptions & { async: true }): Promise;\n (src: string, options: MarkedOptions & { async: false }): ParserOutput;\n (src: string, options?: MarkedOptions | null): ParserOutput | Promise;\n };\n\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const parse: overloadedParse = (src: string, options?: MarkedOptions | null): any => {\n const origOpt = { ...options };\n const opt = { ...this.defaults, ...origOpt };\n\n const throwError = this.onError(!!opt.silent, !!opt.async);\n\n // throw error if an extension set async to true but parse was called with async: false\n if (this.defaults.async === true && origOpt.async === false) {\n return throwError(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.'));\n }\n\n // throw error in case of non string input\n if (typeof src === 'undefined' || src === null) {\n return throwError(new Error('marked(): input parameter is undefined or null'));\n }\n if (typeof src !== 'string') {\n return throwError(new Error('marked(): input parameter is of type '\n + Object.prototype.toString.call(src) + ', string expected'));\n }\n\n if (opt.hooks) {\n opt.hooks.options = opt;\n opt.hooks.block = blockType;\n }\n\n if (opt.async) {\n return (async() => {\n const processedSrc = opt.hooks ? await opt.hooks.preprocess(src) : src;\n const lexer = opt.hooks ? await opt.hooks.provideLexer(blockType) : (blockType ? _Lexer.lex : _Lexer.lexInline);\n const tokens = await lexer(processedSrc, opt);\n const processedTokens = opt.hooks ? await opt.hooks.processAllTokens(tokens) : tokens;\n if (opt.walkTokens) {\n await Promise.all(this.walkTokens(processedTokens, opt.walkTokens));\n }\n const parser = opt.hooks ? await opt.hooks.provideParser(blockType) : (blockType ? _Parser.parse : _Parser.parseInline);\n const html = await parser(processedTokens, opt);\n return opt.hooks ? await opt.hooks.postprocess(html) : html;\n })().catch(throwError);\n }\n\n try {\n if (opt.hooks) {\n src = opt.hooks.preprocess(src) as string;\n }\n const lexer = opt.hooks ? opt.hooks.provideLexer(blockType) : (blockType ? _Lexer.lex : _Lexer.lexInline);\n let tokens = lexer(src, opt);\n if (opt.hooks) {\n tokens = opt.hooks.processAllTokens(tokens);\n }\n if (opt.walkTokens) {\n this.walkTokens(tokens, opt.walkTokens);\n }\n const parser = opt.hooks ? opt.hooks.provideParser(blockType) : (blockType ? _Parser.parse : _Parser.parseInline);\n let html = parser(tokens, opt);\n if (opt.hooks) {\n html = opt.hooks.postprocess(html);\n }\n return html;\n } catch(e) {\n return throwError(e as Error);\n }\n };\n\n return parse;\n }\n\n private onError(silent: boolean, async: boolean) {\n return (e: Error): string | Promise => {\n e.message += '\\nPlease report this to https://github.com/markedjs/marked.';\n\n if (silent) {\n const msg = '

    An error occurred:

    '\n          + escapeHtmlEntities(e.message + '', true)\n          + '
    ';\n if (async) {\n return Promise.resolve(msg);\n }\n return msg;\n }\n\n if (async) {\n return Promise.reject(e);\n }\n throw e;\n };\n }\n}\n", "import { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport { _Tokenizer } from './Tokenizer.ts';\nimport { _Renderer } from './Renderer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { _Hooks } from './Hooks.ts';\nimport { Marked } from './Instance.ts';\nimport {\n _getDefaults,\n changeDefaults,\n _defaults,\n} from './defaults.ts';\nimport type { MarkedExtension, MarkedOptions } from './MarkedOptions.ts';\nimport type { Token, TokensList } from './Tokens.ts';\nimport type { MaybePromise } from './Instance.ts';\n\nconst markedInstance = new Marked();\n\n/**\n * Compiles markdown to HTML asynchronously.\n *\n * @param src String of markdown source to be compiled\n * @param options Hash of options, having async: true\n * @return Promise of string of compiled HTML\n */\nexport function marked(src: string, options: MarkedOptions & { async: true }): Promise;\n\n/**\n * Compiles markdown to HTML.\n *\n * @param src String of markdown source to be compiled\n * @param options Optional hash of options\n * @return String of compiled HTML. Will be a Promise of string if async is set to true by any extensions.\n */\nexport function marked(src: string, options: MarkedOptions & { async: false }): string;\nexport function marked(src: string, options: MarkedOptions & { async: true }): Promise;\nexport function marked(src: string, options?: MarkedOptions | null): string | Promise;\nexport function marked(src: string, opt?: MarkedOptions | null): string | Promise {\n return markedInstance.parse(src, opt);\n}\n\n/**\n * Sets the default options.\n *\n * @param options Hash of options\n */\nmarked.options =\n marked.setOptions = function(options: MarkedOptions) {\n markedInstance.setOptions(options);\n marked.defaults = markedInstance.defaults;\n changeDefaults(marked.defaults);\n return marked;\n };\n\n/**\n * Gets the original marked default options.\n */\nmarked.getDefaults = _getDefaults;\n\nmarked.defaults = _defaults;\n\n/**\n * Use Extension\n */\n\nmarked.use = function(...args: MarkedExtension[]) {\n markedInstance.use(...args);\n marked.defaults = markedInstance.defaults;\n changeDefaults(marked.defaults);\n return marked;\n};\n\n/**\n * Run callback for every token\n */\n\nmarked.walkTokens = function(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) {\n return markedInstance.walkTokens(tokens, callback);\n};\n\n/**\n * Compiles markdown to HTML without enclosing `p` tag.\n *\n * @param src String of markdown source to be compiled\n * @param options Hash of options\n * @return String of compiled HTML\n */\nmarked.parseInline = markedInstance.parseInline;\n\n/**\n * Expose\n */\nmarked.Parser = _Parser;\nmarked.parser = _Parser.parse;\nmarked.Renderer = _Renderer;\nmarked.TextRenderer = _TextRenderer;\nmarked.Lexer = _Lexer;\nmarked.lexer = _Lexer.lex;\nmarked.Tokenizer = _Tokenizer;\nmarked.Hooks = _Hooks;\nmarked.parse = marked;\n\nexport const options = marked.options;\nexport const setOptions = marked.setOptions;\nexport const use = marked.use;\nexport const walkTokens = marked.walkTokens;\nexport const parseInline = marked.parseInline;\nexport const parse = marked;\nexport const parser = _Parser.parse;\nexport const lexer = _Lexer.lex;\nexport { _defaults as defaults, _getDefaults as getDefaults } from './defaults.ts';\nexport { _Lexer as Lexer } from './Lexer.ts';\nexport { _Parser as Parser } from './Parser.ts';\nexport { _Tokenizer as Tokenizer } from './Tokenizer.ts';\nexport { _Renderer as Renderer } from './Renderer.ts';\nexport { _TextRenderer as TextRenderer } from './TextRenderer.ts';\nexport { _Hooks as Hooks } from './Hooks.ts';\nexport { Marked } from './Instance.ts';\nexport type * from './MarkedOptions.ts';\nexport type * from './Tokens.ts';\n"], + "mappings": ";;;;;;;;;;;;AAKO,SAASA,GAA4G,CAC1H,MAAO,CACL,MAAO,GACP,OAAQ,GACR,WAAY,KACZ,IAAK,GACL,MAAO,KACP,SAAU,GACV,SAAU,KACV,OAAQ,GACR,UAAW,KACX,WAAY,IACd,CACF,CAEO,IAAIC,EAAqCD,EAAa,EAEtD,SAASE,EAA+DC,EAA0D,CACvIF,EAAYE,CACd,CCxBA,IAAMC,EAAW,CAAE,KAAM,IAAM,IAAK,EAEpC,SAASC,EAAkBC,EAAyC,CAClE,IAAMC,EAAkB,CAAC,EACzB,OAAQC,GAAmB,CACzB,IAAMC,EAAa,KAAK,IAAI,EAAG,KAAK,IAAI,EAAGD,EAAS,CAAC,CAAC,EAClDE,EAAQH,EAAME,CAAU,EAC5B,OAAKC,IACHA,EAAQJ,EAAYG,CAAU,EAC9BF,EAAME,CAAU,EAAIC,GAEfA,CACT,CACF,CAEA,SAASC,EAAKD,EAAwBE,EAAM,GAAI,CAC9C,IAAIC,EAAS,OAAOH,GAAU,SAAWA,EAAQA,EAAM,OACjDI,EAAM,CACV,QAAS,CAACC,EAAuBC,IAAyB,CACxD,IAAIC,EAAY,OAAOD,GAAQ,SAAWA,EAAMA,EAAI,OACpD,OAAAC,EAAYA,EAAU,QAAQC,EAAM,MAAO,IAAI,EAC/CL,EAASA,EAAO,QAAQE,EAAME,CAAS,EAChCH,CACT,EACA,SAAU,IACD,IAAI,OAAOD,EAAQD,CAAG,CAEjC,EACA,OAAOE,CACT,CAGA,IAAMK,IAAsB,CAACC,EAAI,KAAO,CACxC,GAAI,CACF,MAAO,CAAC,CAAC,IAAI,OAAO,eAAiBA,CAAC,CACxC,MAAQ,CAGN,MAAO,EACT,CACA,GAAG,EAEUF,EAAQ,CACnB,iBAAkB,yBAClB,kBAAmB,cACnB,uBAAwB,gBACxB,eAAgB,OAChB,WAAY,KACZ,kBAAmB,KACnB,gBAAiB,KACjB,aAAc,OACd,kBAAmB,MACnB,cAAe,MACf,oBAAqB,OACrB,UAAW,WACX,gBAAiB,oBACjB,gBAAiB,WACjB,wBAAyB,iCACzB,yBAA0B,mBAC1B,mBAAoB,0BACpB,WAAY,iBACZ,gBAAiB,eACjB,iBAAkB,YAClB,QAAS,SACT,aAAc,WACd,eAAgB,OAChB,gBAAiB,aACjB,kBAAmB,YACnB,gBAAiB,YACjB,iBAAkB,aAClB,eAAgB,YAChB,UAAW,QACX,QAAS,UACT,kBAAmB,iCACnB,gBAAiB,mCACjB,kBAAmB,KACnB,gBAAiB,KACjB,kBAAmB,gCACnB,oBAAqB,gBACrB,WAAY,UACZ,cAAe,WACf,mBAAoB,oDACpB,sBAAuB,qDACvB,MAAO,eACP,cAAe,OACf,SAAU,MACV,UAAW,MACX,UAAW,QACX,eAAgB,WAChB,UAAW,SACX,cAAe,OACf,cAAe,MACf,cAAgBG,GAAiB,IAAI,OAAO,WAAWA,CAAI,8BAA+B,EAC1F,gBAAiBhB,EAAmBG,GAAmB,IAAI,OAAO,QAAQA,CAAM,oDAAqD,CAAC,EACtI,QAASH,EAAmBG,GAAmB,IAAI,OAAO,QAAQA,CAAM,oDAAoD,CAAC,EAC7H,iBAAkBH,EAAmBG,GAAmB,IAAI,OAAO,QAAQA,CAAM,iBAAiB,CAAC,EACnG,kBAAmBH,EAAmBG,GAAmB,IAAI,OAAO,QAAQA,CAAM,IAAI,CAAC,EACvF,eAAgBH,EAAmBG,GAAmB,IAAI,OAAO,QAAQA,CAAM,qBAAsB,GAAG,CAAC,EACzG,qBAAsBH,EAAmBG,GAAmB,IAAI,OAAO,QAAQA,CAAM,IAAI,CAAC,CAC5F,EAMMc,GAAU,uBACVC,GAAY,wDACZC,GAAS,8GACTC,EAAK,qEACLC,GAAU,uCACVC,EAAS,8BACTC,GAAe,iKACfC,GAAWlB,EAAKiB,EAAY,EAC/B,QAAQ,QAASD,CAAM,EACvB,QAAQ,aAAc,mBAAmB,EACzC,QAAQ,UAAW,uBAAuB,EAC1C,QAAQ,cAAe,SAAS,EAChC,QAAQ,WAAY,cAAc,EAClC,QAAQ,QAAS,mBAAmB,EACpC,QAAQ,WAAY,EAAE,EACtB,SAAS,EACNG,GAAcnB,EAAKiB,EAAY,EAClC,QAAQ,QAASD,CAAM,EACvB,QAAQ,aAAc,mBAAmB,EACzC,QAAQ,UAAW,uBAAuB,EAC1C,QAAQ,cAAe,SAAS,EAChC,QAAQ,WAAY,cAAc,EAClC,QAAQ,QAAS,mBAAmB,EACpC,QAAQ,SAAU,mCAAmC,EACrD,SAAS,EACNI,EAAa,uFACbC,GAAY,UACZC,EAAc,mCACdC,GAAMvB,EAAK,6GAA6G,EAC3H,QAAQ,QAASsB,CAAW,EAC5B,QAAQ,QAAS,8DAA8D,EAC/E,SAAS,EAENE,GAAOxB,EAAK,gCAAgC,EAC/C,QAAQ,QAASgB,CAAM,EACvB,SAAS,EAENS,EAAO,gWAMPC,EAAW,gCACXC,GAAO3B,EACX,4dASK,GAAG,EACP,QAAQ,UAAW0B,CAAQ,EAC3B,QAAQ,MAAOD,CAAI,EACnB,QAAQ,YAAa,0EAA0E,EAC/F,SAAS,EAENG,GAAY5B,EAAKoB,CAAU,EAC9B,QAAQ,KAAMN,CAAE,EAChB,QAAQ,UAAW,uBAAuB,EAC1C,QAAQ,YAAa,EAAE,EACvB,QAAQ,SAAU,EAAE,EACpB,QAAQ,aAAc,SAAS,EAC/B,QAAQ,SAAU,gDAAgD,EAClE,QAAQ,OAAQ,wCAAwC,EACxD,QAAQ,OAAQ,6DAA6D,EAC7E,QAAQ,MAAOW,CAAI,EACnB,SAAS,EAENI,GAAa7B,EAAK,yCAAyC,EAC9D,QAAQ,YAAa4B,EAAS,EAC9B,SAAS,EAMNE,EAAc,CAClB,WAAAD,GACA,KAAMjB,GACN,IAAAW,GACA,OAAAV,GACA,QAAAE,GACA,GAAAD,EACA,KAAAa,GACA,SAAAT,GACA,KAAAM,GACA,QAAAb,GACA,UAAAiB,GACA,MAAOnC,EACP,KAAM4B,EACR,EAQMU,GAAW/B,EACf,6JAEsF,EACrF,QAAQ,KAAMc,CAAE,EAChB,QAAQ,UAAW,uBAAuB,EAC1C,QAAQ,aAAc,SAAS,EAC/B,QAAQ,OAAQ,wBAAyB,EACzC,QAAQ,SAAU,gDAAgD,EAClE,QAAQ,OAAQ,6BAA6B,EAC7C,QAAQ,OAAQ,6DAA6D,EAC7E,QAAQ,MAAOW,CAAI,EACnB,SAAS,EAENO,GAAsC,CAC1C,GAAGF,EACH,SAAUX,GACV,MAAOY,GACP,UAAW/B,EAAKoB,CAAU,EACvB,QAAQ,KAAMN,CAAE,EAChB,QAAQ,UAAW,uBAAuB,EAC1C,QAAQ,YAAa,EAAE,EACvB,QAAQ,QAASiB,EAAQ,EACzB,QAAQ,aAAc,SAAS,EAC/B,QAAQ,SAAU,gDAAgD,EAClE,QAAQ,OAAQ,wCAAwC,EACxD,QAAQ,OAAQ,6DAA6D,EAC7E,QAAQ,MAAON,CAAI,EACnB,SAAS,CACd,EAMMQ,GAA2C,CAC/C,GAAGH,EACH,KAAM9B,EACJ,wIAEwE,EACvE,QAAQ,UAAW0B,CAAQ,EAC3B,QAAQ,OAAQ,mKAGkB,EAClC,SAAS,EACZ,IAAK,oEACL,QAAS,yBACT,OAAQjC,EACR,SAAU,mCACV,UAAWO,EAAKoB,CAAU,EACvB,QAAQ,KAAMN,CAAE,EAChB,QAAQ,UAAW;AAAA,EAAiB,EACpC,QAAQ,WAAYI,EAAQ,EAC5B,QAAQ,SAAU,EAAE,EACpB,QAAQ,aAAc,SAAS,EAC/B,QAAQ,UAAW,EAAE,EACrB,QAAQ,QAAS,EAAE,EACnB,QAAQ,QAAS,EAAE,EACnB,QAAQ,OAAQ,EAAE,EAClB,SAAS,CACd,EAMMgB,GAAS,8CACTC,GAAa,sCACbC,GAAK,wBACLC,GAAa,8EAGbC,EAAe,gBACfC,EAAsB,kBACtBC,EAAyB,mBACzBC,GAAczC,EAAK,wBAAyB,GAAG,EAClD,QAAQ,cAAeuC,CAAmB,EAAE,SAAS,EAGlDG,GAA0B,qBAC1BC,GAAiC,uBACjCC,GAAoC,yBAGpCC,GAAY7C,EAAK,yBAA0B,GAAG,EACjD,QAAQ,OAAQ,mGAAmG,EACnH,QAAQ,WAAYQ,GAAqB,WAAa,WAAW,EACjE,QAAQ,OAAQ,yBAAyB,EACzC,QAAQ,OAAQ,gBAAgB,EAChC,SAAS,EAENsC,GAAqB,oEAErBC,GAAiB/C,EAAK8C,GAAoB,GAAG,EAChD,QAAQ,SAAUR,CAAY,EAC9B,SAAS,EAENU,GAAoBhD,EAAK8C,GAAoB,GAAG,EACnD,QAAQ,SAAUJ,EAAuB,EACzC,SAAS,EAENO,GACJ,wQASIC,GAAoBlD,EAAKiD,GAAuB,IAAI,EACvD,QAAQ,iBAAkBT,CAAsB,EAChD,QAAQ,cAAeD,CAAmB,EAC1C,QAAQ,SAAUD,CAAY,EAC9B,SAAS,EAENa,GAAuBnD,EAAKiD,GAAuB,IAAI,EAC1D,QAAQ,iBAAkBL,EAAiC,EAC3D,QAAQ,cAAeD,EAA8B,EACrD,QAAQ,SAAUD,EAAuB,EACzC,SAAS,EAGNU,GAAoBpD,EACxB,mNAMiC,IAAI,EACpC,QAAQ,iBAAkBwC,CAAsB,EAChD,QAAQ,cAAeD,CAAmB,EAC1C,QAAQ,SAAUD,CAAY,EAC9B,SAAS,EAGNe,GAAYrD,EAAK,8BAA+B,GAAG,EACtD,QAAQ,SAAUsC,CAAY,EAC9B,SAAS,EAGNgB,GACJ,qNAQIC,GAAYvD,EAAKsD,GAAe,IAAI,EACvC,QAAQ,iBAAkBd,CAAsB,EAChD,QAAQ,cAAeD,CAAmB,EAC1C,QAAQ,SAAUD,CAAY,EAC9B,SAAS,EAENkB,GAAiBxD,EAAK,YAAa,IAAI,EAC1C,QAAQ,SAAUsC,CAAY,EAC9B,SAAS,EAENmB,GAAWzD,EAAK,qCAAqC,EACxD,QAAQ,SAAU,8BAA8B,EAChD,QAAQ,QAAS,8IAA8I,EAC/J,SAAS,EAEN0D,GAAiB1D,EAAK0B,CAAQ,EAAE,QAAQ,YAAa,KAAK,EAAE,SAAS,EACrEiC,GAAM3D,EACV,0JAKsC,EACrC,QAAQ,UAAW0D,EAAc,EACjC,QAAQ,YAAa,6EAA6E,EAClG,SAAS,EAENE,EAAe,uFAEfC,GAAO7D,EAAK,4EAA4E,EAC3F,QAAQ,QAAS4D,CAAY,EAC7B,QAAQ,OAAQ,yCAAyC,EACzD,QAAQ,QAAS,6DAA6D,EAC9E,SAAS,EAENE,GAAU9D,EAAK,yBAAyB,EAC3C,QAAQ,QAAS4D,CAAY,EAC7B,QAAQ,MAAOtC,CAAW,EAC1B,SAAS,EAENyC,GAAS/D,EAAK,uBAAuB,EACxC,QAAQ,MAAOsB,CAAW,EAC1B,SAAS,EAEN0C,GAAgBhE,EAAK,wBAAyB,GAAG,EACpD,QAAQ,UAAW8D,EAAO,EAC1B,QAAQ,SAAUC,EAAM,EACxB,SAAS,EAENE,GAA2B,qCAM3BC,EAAe,CACnB,WAAYzE,EACZ,eAAA+D,GACA,SAAAC,GACA,UAAAZ,GACA,GAAAT,GACA,KAAMD,GACN,IAAK1C,EACL,UAAWA,EACX,UAAWA,EACX,eAAAsD,GACA,kBAAAG,GACA,kBAAAE,GACA,OAAAlB,GACA,KAAA2B,GACA,OAAAE,GACA,YAAAtB,GACA,QAAAqB,GACA,cAAAE,GACA,IAAAL,GACA,KAAMtB,GACN,IAAK5C,CACP,EAQM0E,GAA6C,CACjD,GAAGD,EACH,KAAMlE,EAAK,yBAAyB,EACjC,QAAQ,QAAS4D,CAAY,EAC7B,SAAS,EACZ,QAAS5D,EAAK,+BAA+B,EAC1C,QAAQ,QAAS4D,CAAY,EAC7B,SAAS,CACd,EAMMQ,EAAwC,CAC5C,GAAGF,EACH,kBAAmBf,GACnB,eAAgBH,GAChB,UAAAK,GACA,UAAAE,GACA,IAAKvD,EAAK,gEAAgE,EACvE,QAAQ,WAAYiE,EAAwB,EAC5C,QAAQ,QAAS,2EAA2E,EAC5F,SAAS,EACZ,WAAY,6EACZ,IAAK,0EACL,KAAMjE,EAAK,qNAAqN,EAC7N,QAAQ,WAAYiE,EAAwB,EAC5C,SAAS,CACd,EAMMI,GAA2C,CAC/C,GAAGD,EACH,GAAIpE,EAAKoC,EAAE,EAAE,QAAQ,OAAQ,GAAG,EAAE,SAAS,EAC3C,KAAMpC,EAAKoE,EAAU,IAAI,EACtB,QAAQ,OAAQ,eAAe,EAC/B,QAAQ,UAAW,GAAG,EACtB,SAAS,CACd,EAMaE,EAAQ,CACnB,OAAQxC,EACR,IAAKE,GACL,SAAUC,EACZ,EAEasC,EAAS,CACpB,OAAQL,EACR,IAAKE,EACL,OAAQC,GACR,SAAUF,EACZ,ECpfA,IAAMK,GAAkD,CACtD,IAAK,QACL,IAAK,OACL,IAAK,OACL,IAAK,SACL,IAAK,OACP,EACMC,GAAwBC,GAAeF,GAAmBE,CAAE,EAE3D,SAASC,EAAmBC,EAAcC,EAAkB,CACjE,GAAIA,GACF,GAAIC,EAAM,WAAW,KAAKF,CAAI,EAC5B,OAAOA,EAAK,QAAQE,EAAM,cAAeL,EAAoB,UAG3DK,EAAM,mBAAmB,KAAKF,CAAI,EACpC,OAAOA,EAAK,QAAQE,EAAM,sBAAuBL,EAAoB,EAIzE,OAAOG,CACT,CAEO,SAASG,EAASC,EAAc,CACrC,GAAI,CACFA,EAAO,UAAUA,CAAI,EAAE,QAAQF,EAAM,cAAe,GAAG,CACzD,MAAQ,CACN,OAAO,IACT,CACA,OAAOE,CACT,CAEO,SAASC,EAAWC,EAAkBC,EAAgB,CAG3D,IAAMC,EAAMF,EAAS,QAAQJ,EAAM,SAAU,CAACO,EAAOC,EAAQC,IAAQ,CACjE,IAAIC,EAAU,GACVC,EAAOH,EACX,KAAO,EAAEG,GAAQ,GAAKF,EAAIE,CAAI,IAAM,MAAMD,EAAU,CAACA,EACrD,OAAIA,EAGK,IAGA,IAEX,CAAC,EACDE,EAAQN,EAAI,MAAMN,EAAM,SAAS,EAC/Ba,EAAI,EAUR,GAPKD,EAAM,CAAC,EAAE,KAAK,GACjBA,EAAM,MAAM,EAEVA,EAAM,OAAS,GAAK,CAACA,EAAM,GAAG,EAAE,GAAG,KAAK,GAC1CA,EAAM,IAAI,EAGRP,EACF,GAAIO,EAAM,OAASP,EACjBO,EAAM,OAAOP,CAAK,MAElB,MAAOO,EAAM,OAASP,GAAOO,EAAM,KAAK,EAAE,EAI9C,KAAOC,EAAID,EAAM,OAAQC,IAEvBD,EAAMC,CAAC,EAAID,EAAMC,CAAC,EAAE,KAAK,EAAE,QAAQb,EAAM,UAAW,GAAG,EAEzD,OAAOY,CACT,CAUO,SAASE,EAAML,EAAaM,EAAWC,EAAkB,CAC9D,IAAMC,EAAIR,EAAI,OACd,GAAIQ,IAAM,EACR,MAAO,GAIT,IAAIC,EAAU,EAGd,KAAOA,EAAUD,GAAG,CAClB,IAAME,EAAWV,EAAI,OAAOQ,EAAIC,EAAU,CAAC,EAC3C,GAAIC,IAAaJ,GAAK,CAACC,EACrBE,YACSC,IAAaJ,GAAKC,EAC3BE,QAEA,MAEJ,CAEA,OAAOT,EAAI,MAAM,EAAGQ,EAAIC,CAAO,CACjC,CAEO,SAASE,GAAuBX,EAAa,CAClD,IAAMY,EAAQZ,EAAI,MAAM;AAAA,CAAI,EACxBa,EAAMD,EAAM,OAAS,EACzB,KAAOC,GAAO,GAAKtB,EAAM,UAAU,KAAKqB,EAAMC,CAAG,CAAC,GAChDA,IAEF,OAAID,EAAM,OAASC,GAAO,EAEjBb,EAGFY,EAAM,MAAM,EAAGC,EAAM,CAAC,EAAE,KAAK;AAAA,CAAI,CAC1C,CAEO,SAASC,GAAmBd,EAAae,EAAW,CACzD,GAAIf,EAAI,QAAQe,EAAE,CAAC,CAAC,IAAM,GACxB,MAAO,GAGT,IAAIC,EAAQ,EACZ,QAASZ,EAAI,EAAGA,EAAIJ,EAAI,OAAQI,IAC9B,GAAIJ,EAAII,CAAC,IAAM,KACbA,YACSJ,EAAII,CAAC,IAAMW,EAAE,CAAC,EACvBC,YACShB,EAAII,CAAC,IAAMW,EAAE,CAAC,IACvBC,IACIA,EAAQ,GACV,OAAOZ,EAIb,OAAIY,EAAQ,EACH,GAGF,EACT,CAEO,SAASC,GAAWC,EAAcC,EAAS,EAAG,CACnD,IAAIC,EAAMD,EACNE,EAAW,GACf,QAAWC,KAAQJ,EACjB,GAAII,IAAS,IAAM,CACjB,IAAMC,EAAQ,EAAKH,EAAM,EACzBC,GAAY,IAAI,OAAOE,CAAK,EAC5BH,GAAOG,CACT,MACEF,GAAYC,EACZF,IAIJ,OAAOC,CACT,CCxJA,SAASG,GAAWC,EAAeC,EAA2CC,EAAaC,EAAeC,EAA0C,CAClJ,IAAMC,EAAOJ,EAAK,KACZK,EAAQL,EAAK,OAAS,KACtBM,EAAOP,EAAI,CAAC,EAAE,QAAQI,EAAM,MAAM,kBAAmB,IAAI,EAE/DD,EAAM,MAAM,OAAS,GACrB,IAAMK,EAAoC,CACxC,KAAMR,EAAI,CAAC,EAAE,OAAO,CAAC,IAAM,IAAM,QAAU,OAC3C,IAAAE,EACA,KAAAG,EACA,MAAAC,EACA,KAAAC,EACA,OAAQJ,EAAM,aAAaI,CAAI,CACjC,EACA,OAAAJ,EAAM,MAAM,OAAS,GACdK,CACT,CAEA,SAASC,GAAuBP,EAAaK,EAAcH,EAAc,CACvE,IAAMM,EAAoBR,EAAI,MAAME,EAAM,MAAM,sBAAsB,EAEtE,GAAIM,IAAsB,KACxB,OAAOH,EAGT,IAAMI,EAAeD,EAAkB,CAAC,EAExC,OAAOH,EACJ,MAAM;AAAA,CAAI,EACV,IAAIK,GAAQ,CACX,IAAMC,EAAoBD,EAAK,MAAMR,EAAM,MAAM,cAAc,EAC/D,GAAIS,IAAsB,KACxB,OAAOD,EAGT,GAAM,CAACE,CAAY,EAAID,EAEvB,OAAIC,EAAa,QAAUH,EAAa,OAC/BC,EAAK,MAAMD,EAAa,MAAM,EAGhCC,CACT,CAAC,EACA,KAAK;AAAA,CAAI,CACd,CAKO,IAAMG,EAAN,KAAiE,CACtE,QACA,MACA,MAEA,YAAYC,EAAuD,CACjE,KAAK,QAAUA,GAAWC,CAC5B,CAEA,MAAMC,EAAuC,CAC3C,IAAMlB,EAAM,KAAK,MAAM,MAAM,QAAQ,KAAKkB,CAAG,EAC7C,GAAIlB,GAAOA,EAAI,CAAC,EAAE,OAAS,EACzB,MAAO,CACL,KAAM,QACN,IAAKA,EAAI,CAAC,CACZ,CAEJ,CAEA,KAAKkB,EAAsC,CACzC,IAAMlB,EAAM,KAAK,MAAM,MAAM,KAAK,KAAKkB,CAAG,EAC1C,GAAIlB,EAAK,CACP,IAAME,EAAM,KAAK,QAAQ,SACrBF,EAAI,CAAC,EACLmB,GAAuBnB,EAAI,CAAC,CAAC,EAC3BO,EAAOL,EAAI,QAAQ,KAAK,MAAM,MAAM,iBAAkB,EAAE,EAC9D,MAAO,CACL,KAAM,OACN,IAAAA,EACA,eAAgB,WAChB,KAAAK,CACF,CACF,CACF,CAEA,OAAOW,EAAsC,CAC3C,IAAMlB,EAAM,KAAK,MAAM,MAAM,OAAO,KAAKkB,CAAG,EAC5C,GAAIlB,EAAK,CACP,IAAME,EAAMF,EAAI,CAAC,EACXO,EAAOE,GAAuBP,EAAKF,EAAI,CAAC,GAAK,GAAI,KAAK,KAAK,EAEjE,MAAO,CACL,KAAM,OACN,IAAAE,EACA,KAAMF,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,KAAK,MAAM,OAAO,eAAgB,IAAI,EAAIA,EAAI,CAAC,EACpF,KAAAO,CACF,CACF,CACF,CAEA,QAAQW,EAAyC,CAC/C,IAAMlB,EAAM,KAAK,MAAM,MAAM,QAAQ,KAAKkB,CAAG,EAC7C,GAAIlB,EAAK,CACP,IAAIO,EAAOP,EAAI,CAAC,EAAE,KAAK,EAGvB,GAAI,KAAK,MAAM,MAAM,WAAW,KAAKO,CAAI,EAAG,CAC1C,IAAMa,EAAUC,EAAMd,EAAM,GAAG,GAC3B,KAAK,QAAQ,UAEN,CAACa,GAAW,KAAK,MAAM,MAAM,gBAAgB,KAAKA,CAAO,KAElEb,EAAOa,EAAQ,KAAK,EAExB,CAEA,MAAO,CACL,KAAM,UACN,IAAKC,EAAMrB,EAAI,CAAC,EAAG;AAAA,CAAI,EACvB,MAAOA,EAAI,CAAC,EAAE,OACd,KAAAO,EACA,OAAQ,KAAK,MAAM,OAAOA,CAAI,CAChC,CACF,CACF,CAEA,GAAGW,EAAoC,CACrC,IAAMlB,EAAM,KAAK,MAAM,MAAM,GAAG,KAAKkB,CAAG,EACxC,GAAIlB,EACF,MAAO,CACL,KAAM,KACN,IAAKqB,EAAMrB,EAAI,CAAC,EAAG;AAAA,CAAI,CACzB,CAEJ,CAEA,WAAWkB,EAA4C,CACrD,IAAMlB,EAAM,KAAK,MAAM,MAAM,WAAW,KAAKkB,CAAG,EAChD,GAAIlB,EAAK,CACP,IAAIsB,EAAQD,EAAMrB,EAAI,CAAC,EAAG;AAAA,CAAI,EAAE,MAAM;AAAA,CAAI,EACtCE,EAAM,GACNK,EAAO,GACLgB,EAAkB,CAAC,EAEzB,KAAOD,EAAM,OAAS,GAAG,CACvB,IAAIE,EAAe,GACbC,EAAe,CAAC,EAElBC,EACJ,IAAKA,EAAI,EAAGA,EAAIJ,EAAM,OAAQI,IAE5B,GAAI,KAAK,MAAM,MAAM,gBAAgB,KAAKJ,EAAMI,CAAC,CAAC,EAChDD,EAAa,KAAKH,EAAMI,CAAC,CAAC,EAC1BF,EAAe,WACN,CAACA,EACVC,EAAa,KAAKH,EAAMI,CAAC,CAAC,MAE1B,OAGJJ,EAAQA,EAAM,MAAMI,CAAC,EAErB,IAAMC,EAAaF,EAAa,KAAK;AAAA,CAAI,EACnCG,EAAcD,EAEjB,QAAQ,KAAK,MAAM,MAAM,wBAAyB;AAAA,OAAU,EAC5D,QAAQ,KAAK,MAAM,MAAM,yBAA0B,EAAE,EACxDzB,EAAMA,EAAM,GAAGA,CAAG;AAAA,EAAKyB,CAAU,GAAKA,EACtCpB,EAAOA,EAAO,GAAGA,CAAI;AAAA,EAAKqB,CAAW,GAAKA,EAI1C,IAAMC,EAAM,KAAK,MAAM,MAAM,IAM7B,GALA,KAAK,MAAM,MAAM,IAAM,GACvB,KAAK,MAAM,YAAYD,EAAaL,EAAQ,EAAI,EAChD,KAAK,MAAM,MAAM,IAAMM,EAGnBP,EAAM,SAAW,EACnB,MAGF,IAAMQ,EAAYP,EAAO,GAAG,EAAE,EAE9B,GAAIO,GAAW,OAAS,OAEtB,MACK,GAAIA,GAAW,OAAS,aAAc,CAE3C,IAAMC,EAAWD,EACXE,EAAUD,EAAS,IAAM;AAAA,EAAOT,EAAM,KAAK;AAAA,CAAI,EAC/CW,EAAW,KAAK,WAAWD,CAAO,EACxCT,EAAOA,EAAO,OAAS,CAAC,EAAIU,EAE5B/B,EAAMA,EAAI,UAAU,EAAGA,EAAI,OAAS6B,EAAS,IAAI,MAAM,EAAIE,EAAS,IACpE1B,EAAOA,EAAK,UAAU,EAAGA,EAAK,OAASwB,EAAS,KAAK,MAAM,EAAIE,EAAS,KACxE,KACF,SAAWH,GAAW,OAAS,OAAQ,CAErC,IAAMC,EAAWD,EACXE,EAAUD,EAAS,IAAM;AAAA,EAAOT,EAAM,KAAK;AAAA,CAAI,EAC/CW,EAAW,KAAK,KAAKD,CAAO,EAClCT,EAAOA,EAAO,OAAS,CAAC,EAAIU,EAE5B/B,EAAMA,EAAI,UAAU,EAAGA,EAAI,OAAS4B,EAAU,IAAI,MAAM,EAAIG,EAAS,IACrE1B,EAAOA,EAAK,UAAU,EAAGA,EAAK,OAASwB,EAAS,IAAI,MAAM,EAAIE,EAAS,IACvEX,EAAQU,EAAQ,UAAUT,EAAO,GAAG,EAAE,EAAG,IAAI,MAAM,EAAE,MAAM;AAAA,CAAI,EAC/D,QACF,CACF,CAEA,MAAO,CACL,KAAM,aACN,IAAArB,EACA,OAAAqB,EACA,KAAAhB,CACF,CACF,CACF,CAEA,KAAKW,EAAsC,CACzC,IAAIlB,EAAM,KAAK,MAAM,MAAM,KAAK,KAAKkB,CAAG,EACxC,GAAIlB,EAAK,CACP,IAAIkC,EAAOlC,EAAI,CAAC,EAAE,KAAK,EACjBmC,EAAYD,EAAK,OAAS,EAE1BE,EAAoB,CACxB,KAAM,OACN,IAAK,GACL,QAASD,EACT,MAAOA,EAAY,CAACD,EAAK,MAAM,EAAG,EAAE,EAAI,GACxC,MAAO,GACP,MAAO,CAAC,CACV,EAEAA,EAAOC,EAAY,aAAaD,EAAK,MAAM,EAAE,CAAC,GAAK,KAAKA,CAAI,GAExD,KAAK,QAAQ,WACfA,EAAOC,EAAYD,EAAO,SAI5B,IAAMG,EAAY,KAAK,MAAM,MAAM,cAAcH,CAAI,EACjDI,EAAoB,GAExB,KAAOpB,GAAK,CACV,IAAIqB,EAAW,GACXrC,EAAM,GACNsC,EAAe,GAKnB,GAJI,EAAExC,EAAMqC,EAAU,KAAKnB,CAAG,IAI1B,KAAK,MAAM,MAAM,GAAG,KAAKA,CAAG,EAC9B,MAGFhB,EAAMF,EAAI,CAAC,EACXkB,EAAMA,EAAI,UAAUhB,EAAI,MAAM,EAE9B,IAAIuC,EAAOC,GAAW1C,EAAI,CAAC,EAAE,MAAM;AAAA,EAAM,CAAC,EAAE,CAAC,EAAGA,EAAI,CAAC,EAAE,MAAM,EACzD2C,EAAWzB,EAAI,MAAM;AAAA,EAAM,CAAC,EAAE,CAAC,EAC/B0B,EAAY,CAACH,EAAK,KAAK,EAEvBI,EAAS,EAmBb,GAlBI,KAAK,QAAQ,UACfA,EAAS,EACTL,EAAeC,EAAK,UAAU,GACrBG,EACTC,EAAS7C,EAAI,CAAC,EAAE,OAAS,GAEzB6C,EAASJ,EAAK,OAAO,KAAK,MAAM,MAAM,YAAY,EAClDI,EAASA,EAAS,EAAI,EAAIA,EAC1BL,EAAeC,EAAK,MAAMI,CAAM,EAChCA,GAAU7C,EAAI,CAAC,EAAE,QAGf4C,GAAa,KAAK,MAAM,MAAM,UAAU,KAAKD,CAAQ,IACvDzC,GAAOyC,EAAW;AAAA,EAClBzB,EAAMA,EAAI,UAAUyB,EAAS,OAAS,CAAC,EACvCJ,EAAW,IAGT,CAACA,EAAU,CACb,IAAMO,EAAkB,KAAK,MAAM,MAAM,gBAAgBD,CAAM,EACzDE,GAAU,KAAK,MAAM,MAAM,QAAQF,CAAM,EACzCG,GAAmB,KAAK,MAAM,MAAM,iBAAiBH,CAAM,EAC3DI,GAAoB,KAAK,MAAM,MAAM,kBAAkBJ,CAAM,EAC7DK,GAAiB,KAAK,MAAM,MAAM,eAAeL,CAAM,EACvDM,GAAuB,KAAK,MAAM,MAAM,qBAAqBN,CAAM,EAGzE,KAAO3B,GAAK,CACV,IAAMkC,EAAUlC,EAAI,MAAM;AAAA,EAAM,CAAC,EAAE,CAAC,EAChCmC,EAqCJ,GApCAV,EAAWS,EAGP,KAAK,QAAQ,UACfT,EAAWA,EAAS,QAAQ,KAAK,MAAM,MAAM,mBAAoB,IAAI,EACrEU,EAAsBV,GAEtBU,EAAsBV,EAAS,QAAQ,KAAK,MAAM,MAAM,cAAe,MAAM,EAI3EK,GAAiB,KAAKL,CAAQ,GAK9BM,GAAkB,KAAKN,CAAQ,GAK/BO,GAAe,KAAKP,CAAQ,GAK5BQ,GAAqB,KAAKR,CAAQ,GAKlCG,EAAgB,KAAKH,CAAQ,GAK7BI,GAAQ,KAAKJ,CAAQ,EACvB,MAGF,GAAIU,EAAoB,OAAO,KAAK,MAAM,MAAM,YAAY,GAAKR,GAAU,CAACF,EAAS,KAAK,EACxFH,GAAgB;AAAA,EAAOa,EAAoB,MAAMR,CAAM,MAClD,CAgBL,GAdID,GAKAH,EAAK,QAAQ,KAAK,MAAM,MAAM,cAAe,MAAM,EAAE,OAAO,KAAK,MAAM,MAAM,YAAY,GAAK,GAG9FO,GAAiB,KAAKP,CAAI,GAG1BQ,GAAkB,KAAKR,CAAI,GAG3BM,GAAQ,KAAKN,CAAI,EACnB,MAGFD,GAAgB;AAAA,EAAOG,CACzB,CAEAC,EAAY,CAACD,EAAS,KAAK,EAE3BzC,GAAOkD,EAAU;AAAA,EACjBlC,EAAMA,EAAI,UAAUkC,EAAQ,OAAS,CAAC,EACtCX,EAAOY,EAAoB,MAAMR,CAAM,CACzC,CACF,CAEKT,EAAK,QAEJE,EACFF,EAAK,MAAQ,GACJ,KAAK,MAAM,MAAM,gBAAgB,KAAKlC,CAAG,IAClDoC,EAAoB,KAIxBF,EAAK,MAAM,KAAK,CACd,KAAM,YACN,IAAAlC,EACA,KAAM,CAAC,CAAC,KAAK,QAAQ,KAAO,KAAK,MAAM,MAAM,WAAW,KAAKsC,CAAY,EACzE,MAAO,GACP,KAAMA,EACN,OAAQ,CAAC,CACX,CAAC,EAEDJ,EAAK,KAAOlC,CACd,CAGA,IAAMoD,EAAWlB,EAAK,MAAM,GAAG,EAAE,EACjC,GAAIkB,EACFA,EAAS,IAAMA,EAAS,IAAI,QAAQ,EACpCA,EAAS,KAAOA,EAAS,KAAK,QAAQ,MAGtC,QAEFlB,EAAK,IAAMA,EAAK,IAAI,QAAQ,EAG5B,QAAWmB,KAAQnB,EAAK,MAAO,CAC7B,KAAK,MAAM,MAAM,IAAM,GACvBmB,EAAK,OAAS,KAAK,MAAM,YAAYA,EAAK,KAAM,CAAC,CAAC,EAClD,IAAMC,EAAYD,EAAK,OAAO,CAAC,EAC/B,GAAIA,EAAK,OAASC,GAAW,OAAS,QAAUA,GAAW,OAAS,aAAc,CAEhFD,EAAK,KAAOA,EAAK,KAAK,QAAQ,KAAK,MAAM,MAAM,gBAAiB,EAAE,EAClEC,EAAU,IAAMA,EAAU,IAAI,QAAQ,KAAK,MAAM,MAAM,gBAAiB,EAAE,EAC1EA,EAAU,KAAOA,EAAU,KAAK,QAAQ,KAAK,MAAM,MAAM,gBAAiB,EAAE,EAC5E,QAAS9B,EAAI,KAAK,MAAM,YAAY,OAAS,EAAGA,GAAK,EAAGA,IACtD,GAAI,KAAK,MAAM,MAAM,WAAW,KAAK,KAAK,MAAM,YAAYA,CAAC,EAAE,GAAG,EAAG,CACnE,KAAK,MAAM,YAAYA,CAAC,EAAE,IAAM,KAAK,MAAM,YAAYA,CAAC,EAAE,IAAI,QAAQ,KAAK,MAAM,MAAM,gBAAiB,EAAE,EAC1G,KACF,CAGF,IAAM+B,EAAU,KAAK,MAAM,MAAM,iBAAiB,KAAKF,EAAK,GAAG,EAC/D,GAAIE,EAAS,CACX,IAAMC,EAAiC,CACrC,KAAM,WACN,IAAKD,EAAQ,CAAC,EAAI,IAClB,QAASA,EAAQ,CAAC,IAAM,KAC1B,EACAF,EAAK,QAAUG,EAAc,QACzBtB,EAAK,MACHmB,EAAK,OAAO,CAAC,GAAK,CAAC,YAAa,MAAM,EAAE,SAASA,EAAK,OAAO,CAAC,EAAE,IAAI,GAAK,WAAYA,EAAK,OAAO,CAAC,GAAKA,EAAK,OAAO,CAAC,EAAE,QACxHA,EAAK,OAAO,CAAC,EAAE,IAAMG,EAAc,IAAMH,EAAK,OAAO,CAAC,EAAE,IACxDA,EAAK,OAAO,CAAC,EAAE,KAAOG,EAAc,IAAMH,EAAK,OAAO,CAAC,EAAE,KACzDA,EAAK,OAAO,CAAC,EAAE,OAAO,QAAQG,CAAa,GAE3CH,EAAK,OAAO,QAAQ,CAClB,KAAM,YACN,IAAKG,EAAc,IACnB,KAAMA,EAAc,IACpB,OAAQ,CAACA,CAAa,CACxB,CAAC,EAGHH,EAAK,OAAO,QAAQG,CAAa,CAErC,CACF,MAAWH,EAAK,OACdA,EAAK,KAAO,IAGd,GAAI,CAACnB,EAAK,MAAO,CAEf,IAAMuB,EAAUJ,EAAK,OAAO,OAAOK,GAAKA,EAAE,OAAS,OAAO,EACpDC,EAAwBF,EAAQ,OAAS,GAAKA,EAAQ,KAAKC,GAAK,KAAK,MAAM,MAAM,QAAQ,KAAKA,EAAE,GAAG,CAAC,EAE1GxB,EAAK,MAAQyB,CACf,CACF,CAGA,GAAIzB,EAAK,MACP,QAAWmB,KAAQnB,EAAK,MAAO,CAC7BmB,EAAK,MAAQ,GACb,QAAW/C,KAAS+C,EAAK,OACnB/C,EAAM,OAAS,SACjBA,EAAM,KAAO,YAGnB,CAGF,OAAO4B,CACT,CACF,CAEA,KAAKlB,EAAsC,CACzC,IAAMlB,EAAM,KAAK,MAAM,MAAM,KAAK,KAAKkB,CAAG,EAC1C,GAAIlB,EAAK,CACP,IAAME,EAAMiB,GAAuBnB,EAAI,CAAC,CAAC,EAQzC,MAP2B,CACzB,KAAM,OACN,MAAO,GACP,IAAAE,EACA,IAAKF,EAAI,CAAC,IAAM,OAASA,EAAI,CAAC,IAAM,UAAYA,EAAI,CAAC,IAAM,QAC3D,KAAME,CACR,CAEF,CACF,CAEA,IAAIgB,EAAqC,CACvC,IAAMlB,EAAM,KAAK,MAAM,MAAM,IAAI,KAAKkB,CAAG,EACzC,GAAIlB,EAAK,CACP,IAAM8D,EAAM9D,EAAI,CAAC,EAAE,YAAY,EAAE,QAAQ,KAAK,MAAM,MAAM,oBAAqB,GAAG,EAC5EK,EAAOL,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAE,QAAQ,KAAK,MAAM,MAAM,aAAc,IAAI,EAAE,QAAQ,KAAK,MAAM,OAAO,eAAgB,IAAI,EAAI,GACtHM,EAAQN,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAE,UAAU,EAAGA,EAAI,CAAC,EAAE,OAAS,CAAC,EAAE,QAAQ,KAAK,MAAM,OAAO,eAAgB,IAAI,EAAIA,EAAI,CAAC,EACrH,MAAO,CACL,KAAM,MACN,IAAA8D,EACA,IAAKzC,EAAMrB,EAAI,CAAC,EAAG;AAAA,CAAI,EACvB,KAAAK,EACA,MAAAC,CACF,CACF,CACF,CAEA,MAAMY,EAAuC,CAC3C,IAAMlB,EAAM,KAAK,MAAM,MAAM,MAAM,KAAKkB,CAAG,EAK3C,GAJI,CAAClB,GAID,CAAC,KAAK,MAAM,MAAM,eAAe,KAAKA,EAAI,CAAC,CAAC,EAE9C,OAGF,IAAM+D,EAAUC,EAAWhE,EAAI,CAAC,CAAC,EAC3BiE,EAASjE,EAAI,CAAC,EAAE,QAAQ,KAAK,MAAM,MAAM,gBAAiB,EAAE,EAAE,MAAM,GAAG,EACvEkE,EAAOlE,EAAI,CAAC,GAAG,KAAK,EAAIA,EAAI,CAAC,EAAE,QAAQ,KAAK,MAAM,MAAM,kBAAmB,EAAE,EAAE,MAAM;AAAA,CAAI,EAAI,CAAC,EAE9FuD,EAAqB,CACzB,KAAM,QACN,IAAKlC,EAAMrB,EAAI,CAAC,EAAG;AAAA,CAAI,EACvB,OAAQ,CAAC,EACT,MAAO,CAAC,EACR,KAAM,CAAC,CACT,EAEA,GAAI+D,EAAQ,SAAWE,EAAO,OAK9B,SAAWE,KAASF,EACd,KAAK,MAAM,MAAM,gBAAgB,KAAKE,CAAK,EAC7CZ,EAAK,MAAM,KAAK,OAAO,EACd,KAAK,MAAM,MAAM,iBAAiB,KAAKY,CAAK,EACrDZ,EAAK,MAAM,KAAK,QAAQ,EACf,KAAK,MAAM,MAAM,eAAe,KAAKY,CAAK,EACnDZ,EAAK,MAAM,KAAK,MAAM,EAEtBA,EAAK,MAAM,KAAK,IAAI,EAIxB,QAAS7B,EAAI,EAAGA,EAAIqC,EAAQ,OAAQrC,IAClC6B,EAAK,OAAO,KAAK,CACf,KAAMQ,EAAQrC,CAAC,EACf,OAAQ,KAAK,MAAM,OAAOqC,EAAQrC,CAAC,CAAC,EACpC,OAAQ,GACR,MAAO6B,EAAK,MAAM7B,CAAC,CACrB,CAAC,EAGH,QAAW0C,KAAOF,EAChBX,EAAK,KAAK,KAAKS,EAAWI,EAAKb,EAAK,OAAO,MAAM,EAAE,IAAI,CAACc,EAAM3C,KACrD,CACL,KAAM2C,EACN,OAAQ,KAAK,MAAM,OAAOA,CAAI,EAC9B,OAAQ,GACR,MAAOd,EAAK,MAAM7B,CAAC,CACrB,EACD,CAAC,EAGJ,OAAO6B,EACT,CAEA,SAASrC,EAAyC,CAChD,IAAMlB,EAAM,KAAK,MAAM,MAAM,SAAS,KAAKkB,CAAG,EAC9C,GAAIlB,EAAK,CACP,IAAMO,EAAOP,EAAI,CAAC,EAAE,KAAK,EACzB,MAAO,CACL,KAAM,UACN,IAAKqB,EAAMrB,EAAI,CAAC,EAAG;AAAA,CAAI,EACvB,MAAOA,EAAI,CAAC,EAAE,OAAO,CAAC,IAAM,IAAM,EAAI,EACtC,KAAAO,EACA,OAAQ,KAAK,MAAM,OAAOA,CAAI,CAChC,CACF,CACF,CAEA,UAAUW,EAA2C,CACnD,IAAMlB,EAAM,KAAK,MAAM,MAAM,UAAU,KAAKkB,CAAG,EAC/C,GAAIlB,EAAK,CACP,IAAMO,EAAOP,EAAI,CAAC,EAAE,OAAOA,EAAI,CAAC,EAAE,OAAS,CAAC,IAAM;AAAA,EAC9CA,EAAI,CAAC,EAAE,MAAM,EAAG,EAAE,EAClBA,EAAI,CAAC,EACT,MAAO,CACL,KAAM,YACN,IAAKA,EAAI,CAAC,EACV,KAAAO,EACA,OAAQ,KAAK,MAAM,OAAOA,CAAI,CAChC,CACF,CACF,CAEA,KAAKW,EAAsC,CACzC,IAAMlB,EAAM,KAAK,MAAM,MAAM,KAAK,KAAKkB,CAAG,EAC1C,GAAIlB,EACF,MAAO,CACL,KAAM,OACN,IAAKA,EAAI,CAAC,EACV,KAAMA,EAAI,CAAC,EACX,OAAQ,KAAK,MAAM,OAAOA,EAAI,CAAC,CAAC,CAClC,CAEJ,CAEA,OAAOkB,EAAwC,CAC7C,IAAMlB,EAAM,KAAK,MAAM,OAAO,OAAO,KAAKkB,CAAG,EAC7C,GAAIlB,EACF,MAAO,CACL,KAAM,SACN,IAAKA,EAAI,CAAC,EACV,KAAMA,EAAI,CAAC,CACb,CAEJ,CAEA,IAAIkB,EAAqC,CACvC,IAAMlB,EAAM,KAAK,MAAM,OAAO,IAAI,KAAKkB,CAAG,EAC1C,GAAIlB,EACF,MAAI,CAAC,KAAK,MAAM,MAAM,QAAU,KAAK,MAAM,MAAM,UAAU,KAAKA,EAAI,CAAC,CAAC,EACpE,KAAK,MAAM,MAAM,OAAS,GACjB,KAAK,MAAM,MAAM,QAAU,KAAK,MAAM,MAAM,QAAQ,KAAKA,EAAI,CAAC,CAAC,IACxE,KAAK,MAAM,MAAM,OAAS,IAExB,CAAC,KAAK,MAAM,MAAM,YAAc,KAAK,MAAM,MAAM,kBAAkB,KAAKA,EAAI,CAAC,CAAC,EAChF,KAAK,MAAM,MAAM,WAAa,GACrB,KAAK,MAAM,MAAM,YAAc,KAAK,MAAM,MAAM,gBAAgB,KAAKA,EAAI,CAAC,CAAC,IACpF,KAAK,MAAM,MAAM,WAAa,IAGzB,CACL,KAAM,OACN,IAAKA,EAAI,CAAC,EACV,OAAQ,KAAK,MAAM,MAAM,OACzB,WAAY,KAAK,MAAM,MAAM,WAC7B,MAAO,GACP,KAAMA,EAAI,CAAC,CACb,CAEJ,CAEA,KAAKkB,EAAqD,CACxD,IAAMlB,EAAM,KAAK,MAAM,OAAO,KAAK,KAAKkB,CAAG,EAC3C,GAAIlB,EAAK,CACP,IAAMsE,EAAatE,EAAI,CAAC,EAAE,KAAK,EAC/B,GAAI,CAAC,KAAK,QAAQ,UAAY,KAAK,MAAM,MAAM,kBAAkB,KAAKsE,CAAU,EAAG,CAEjF,GAAI,CAAE,KAAK,MAAM,MAAM,gBAAgB,KAAKA,CAAU,EACpD,OAIF,IAAMC,EAAalD,EAAMiD,EAAW,MAAM,EAAG,EAAE,EAAG,IAAI,EACtD,IAAKA,EAAW,OAASC,EAAW,QAAU,IAAM,EAClD,MAEJ,KAAO,CAEL,IAAMC,EAAiBC,GAAmBzE,EAAI,CAAC,EAAG,IAAI,EACtD,GAAIwE,IAAmB,GAErB,OAGF,GAAIA,EAAiB,GAAI,CAEvB,IAAME,GADQ1E,EAAI,CAAC,EAAE,QAAQ,GAAG,IAAM,EAAI,EAAI,GACtBA,EAAI,CAAC,EAAE,OAASwE,EACxCxE,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAE,UAAU,EAAGwE,CAAc,EAC3CxE,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAE,UAAU,EAAG0E,CAAO,EAAE,KAAK,EAC3C1E,EAAI,CAAC,EAAI,EACX,CACF,CACA,IAAIK,EAAOL,EAAI,CAAC,EACZM,EAAQ,GACZ,GAAI,KAAK,QAAQ,SAAU,CAEzB,IAAML,EAAO,KAAK,MAAM,MAAM,kBAAkB,KAAKI,CAAI,EAErDJ,IACFI,EAAOJ,EAAK,CAAC,EACbK,EAAQL,EAAK,CAAC,EAElB,MACEK,EAAQN,EAAI,CAAC,EAAIA,EAAI,CAAC,EAAE,MAAM,EAAG,EAAE,EAAI,GAGzC,OAAAK,EAAOA,EAAK,KAAK,EACb,KAAK,MAAM,MAAM,kBAAkB,KAAKA,CAAI,IAC1C,KAAK,QAAQ,UAAY,CAAE,KAAK,MAAM,MAAM,gBAAgB,KAAKiE,CAAU,EAE7EjE,EAAOA,EAAK,MAAM,CAAC,EAEnBA,EAAOA,EAAK,MAAM,EAAG,EAAE,GAGpBN,GAAWC,EAAK,CACrB,KAAMK,GAAOA,EAAK,QAAQ,KAAK,MAAM,OAAO,eAAgB,IAAI,EAChE,MAAOC,GAAQA,EAAM,QAAQ,KAAK,MAAM,OAAO,eAAgB,IAAI,CACrE,EAAGN,EAAI,CAAC,EAAG,KAAK,MAAO,KAAK,KAAK,CACnC,CACF,CAEA,QAAQkB,EAAayD,EAAoE,CACvF,IAAI3E,EACJ,IAAKA,EAAM,KAAK,MAAM,OAAO,QAAQ,KAAKkB,CAAG,KACvClB,EAAM,KAAK,MAAM,OAAO,OAAO,KAAKkB,CAAG,GAAI,CAC/C,IAAM0D,GAAc5E,EAAI,CAAC,GAAKA,EAAI,CAAC,GAAG,QAAQ,KAAK,MAAM,MAAM,oBAAqB,GAAG,EACjFC,EAAO0E,EAAMC,EAAW,YAAY,CAAC,EAC3C,GAAI,CAAC3E,EAAM,CACT,IAAMM,EAAOP,EAAI,CAAC,EAAE,OAAO,CAAC,EAC5B,MAAO,CACL,KAAM,OACN,IAAKO,EACL,KAAAA,CACF,CACF,CACA,OAAOR,GAAWC,EAAKC,EAAMD,EAAI,CAAC,EAAG,KAAK,MAAO,KAAK,KAAK,CAC7D,CACF,CAEA,SAASkB,EAAa2D,EAAmBC,EAAW,GAA2C,CAC7F,IAAIC,EAAQ,KAAK,MAAM,OAAO,eAAe,KAAK7D,CAAG,EAKrD,GAJI,CAAC6D,GACD,CAACA,EAAM,CAAC,GAAK,CAACA,EAAM,CAAC,GAAK,CAACA,EAAM,CAAC,GAAK,CAACA,EAAM,CAAC,GAG/CA,EAAM,CAAC,GAAKD,EAAS,MAAM,KAAK,MAAM,MAAM,mBAAmB,EAAG,OAItE,GAAI,EAFaC,EAAM,CAAC,GAAKA,EAAM,CAAC,GAAK,KAExB,CAACD,GAAY,KAAK,MAAM,OAAO,YAAY,KAAKA,CAAQ,EAAG,CAE1E,IAAME,EAAU,CAAC,GAAGD,EAAM,CAAC,CAAC,EAAE,OAAS,EACnCE,EAAQC,EAASC,EAAaH,EAASI,EAAgB,EAErDC,EAASN,EAAM,CAAC,EAAE,CAAC,IAAM,IAAM,KAAK,MAAM,OAAO,kBAAoB,KAAK,MAAM,OAAO,kBAM7F,IALAM,EAAO,UAAY,EAGnBR,EAAYA,EAAU,MAAM,GAAK3D,EAAI,OAAS8D,CAAO,GAE7CD,EAAQM,EAAO,KAAKR,CAAS,KAAO,MAAM,CAGhD,GAFAI,EAASF,EAAM,CAAC,GAAKA,EAAM,CAAC,GAAKA,EAAM,CAAC,GAAKA,EAAM,CAAC,GAAKA,EAAM,CAAC,GAAKA,EAAM,CAAC,EAExE,CAACE,EAAQ,SAIb,GAFAC,EAAU,CAAC,GAAGD,CAAM,EAAE,OAElBF,EAAM,CAAC,GAAKA,EAAM,CAAC,EAAG,CACxBI,GAAcD,EACd,QACF,UAAWH,EAAM,CAAC,GAAKA,EAAM,CAAC,IACxBC,EAAU,GAAK,GAAGA,EAAUE,GAAW,GAAI,CAC7CE,GAAiBF,EACjB,QACF,CAKF,GAFAC,GAAcD,EAEVC,EAAa,EAAG,SAGpBD,EAAU,KAAK,IAAIA,EAASA,EAAUC,EAAaC,CAAa,EAEhE,IAAME,EAAiB,CAAC,GAAGP,EAAM,CAAC,CAAC,EAAE,CAAC,EAAE,OAClC7E,EAAMgB,EAAI,MAAM,EAAG8D,EAAUD,EAAM,MAAQO,EAAiBJ,CAAO,EAGzE,GAAI,KAAK,IAAIF,EAASE,CAAO,EAAI,EAAG,CAClC,IAAM3E,EAAOL,EAAI,MAAM,EAAG,EAAE,EAC5B,MAAO,CACL,KAAM,KACN,IAAAA,EACA,KAAAK,EACA,OAAQ,KAAK,MAAM,aAAaA,CAAI,CACtC,CACF,CAGA,IAAMA,EAAOL,EAAI,MAAM,EAAG,EAAE,EAC5B,MAAO,CACL,KAAM,SACN,IAAAA,EACA,KAAAK,EACA,OAAQ,KAAK,MAAM,aAAaA,CAAI,CACtC,CACF,CACF,CACF,CAEA,SAASW,EAA0C,CACjD,IAAMlB,EAAM,KAAK,MAAM,OAAO,KAAK,KAAKkB,CAAG,EAC3C,GAAIlB,EAAK,CACP,IAAIO,EAAOP,EAAI,CAAC,EAAE,QAAQ,KAAK,MAAM,MAAM,kBAAmB,GAAG,EAC3DuF,EAAmB,KAAK,MAAM,MAAM,aAAa,KAAKhF,CAAI,EAC1DiF,EAA0B,KAAK,MAAM,MAAM,kBAAkB,KAAKjF,CAAI,GAAK,KAAK,MAAM,MAAM,gBAAgB,KAAKA,CAAI,EAC3H,OAAIgF,GAAoBC,IACtBjF,EAAOA,EAAK,UAAU,EAAGA,EAAK,OAAS,CAAC,GAEnC,CACL,KAAM,WACN,IAAKP,EAAI,CAAC,EACV,KAAAO,CACF,CACF,CACF,CAEA,GAAGW,EAAoC,CACrC,IAAMlB,EAAM,KAAK,MAAM,OAAO,GAAG,KAAKkB,CAAG,EACzC,GAAIlB,EACF,MAAO,CACL,KAAM,KACN,IAAKA,EAAI,CAAC,CACZ,CAEJ,CAEA,IAAIkB,EAAa2D,EAAmBC,EAAW,GAA4B,CACzE,IAAIC,EAAQ,KAAK,MAAM,OAAO,UAAU,KAAK7D,CAAG,EAChD,GAAI,CAAC6D,EAAO,OAIZ,GAAI,EAFaA,EAAM,CAAC,GAAK,KAEZ,CAACD,GAAY,KAAK,MAAM,OAAO,YAAY,KAAKA,CAAQ,EAAG,CAE1E,IAAME,EAAU,CAAC,GAAGD,EAAM,CAAC,CAAC,EAAE,OAAS,EACnCE,EAAQC,EAASC,EAAaH,EAE5BK,EAAS,KAAK,MAAM,OAAO,UAMjC,IALAA,EAAO,UAAY,EAGnBR,EAAYA,EAAU,MAAM,GAAK3D,EAAI,OAAS8D,CAAO,GAE7CD,EAAQM,EAAO,KAAKR,CAAS,KAAO,MAAM,CAOhD,GANAI,EAASF,EAAM,CAAC,GAAKA,EAAM,CAAC,GAAKA,EAAM,CAAC,GAAKA,EAAM,CAAC,GAAKA,EAAM,CAAC,GAAKA,EAAM,CAAC,EAExE,CAACE,IAELC,EAAU,CAAC,GAAGD,CAAM,EAAE,OAElBC,IAAYF,GAAS,SAEzB,GAAID,EAAM,CAAC,GAAKA,EAAM,CAAC,EAAG,CACxBI,GAAcD,EACd,QACF,CAIA,GAFAC,GAAcD,EAEVC,EAAa,EAAG,SAGpBD,EAAU,KAAK,IAAIA,EAASA,EAAUC,CAAU,EAEhD,IAAMG,EAAiB,CAAC,GAAGP,EAAM,CAAC,CAAC,EAAE,CAAC,EAAE,OAClC7E,EAAMgB,EAAI,MAAM,EAAG8D,EAAUD,EAAM,MAAQO,EAAiBJ,CAAO,EAGnE3E,EAAOL,EAAI,MAAM8E,EAAS,CAACA,CAAO,EACxC,MAAO,CACL,KAAM,MACN,IAAA9E,EACA,KAAAK,EACA,OAAQ,KAAK,MAAM,aAAaA,CAAI,CACtC,CACF,CACF,CACF,CAEA,SAASW,EAAsC,CAC7C,IAAMlB,EAAM,KAAK,MAAM,OAAO,SAAS,KAAKkB,CAAG,EAC/C,GAAIlB,EAAK,CACP,IAAIO,EAAMF,EACV,OAAIL,EAAI,CAAC,IAAM,KACbO,EAAOP,EAAI,CAAC,EACZK,EAAO,UAAYE,IAEnBA,EAAOP,EAAI,CAAC,EACZK,EAAOE,GAGF,CACL,KAAM,OACN,IAAKP,EAAI,CAAC,EACV,KAAAO,EACA,KAAAF,EACA,OAAQ,CACN,CACE,KAAM,OACN,IAAKE,EACL,KAAAA,CACF,CACF,CACF,CACF,CACF,CAEA,IAAIW,EAAsC,CACxC,IAAIlB,EACJ,GAAIA,EAAM,KAAK,MAAM,OAAO,IAAI,KAAKkB,CAAG,EAAG,CACzC,IAAIX,EAAMF,EACV,GAAIL,EAAI,CAAC,IAAM,IACbO,EAAOP,EAAI,CAAC,EACZK,EAAO,UAAYE,MACd,CAEL,IAAIkF,EACJ,GACEA,EAAczF,EAAI,CAAC,EACnBA,EAAI,CAAC,EAAI,KAAK,MAAM,OAAO,WAAW,KAAKA,EAAI,CAAC,CAAC,IAAI,CAAC,GAAK,SACpDyF,IAAgBzF,EAAI,CAAC,GAC9BO,EAAOP,EAAI,CAAC,EACRA,EAAI,CAAC,IAAM,OACbK,EAAO,UAAYL,EAAI,CAAC,EAExBK,EAAOL,EAAI,CAAC,CAEhB,CACA,MAAO,CACL,KAAM,OACN,IAAKA,EAAI,CAAC,EACV,KAAAO,EACA,KAAAF,EACA,OAAQ,CACN,CACE,KAAM,OACN,IAAKE,EACL,KAAAA,CACF,CACF,CACF,CACF,CACF,CAEA,WAAWW,EAAsC,CAC/C,IAAMlB,EAAM,KAAK,MAAM,OAAO,KAAK,KAAKkB,CAAG,EAC3C,GAAIlB,EAAK,CACP,IAAM0F,EAAU,KAAK,MAAM,MAAM,WACjC,MAAO,CACL,KAAM,OACN,IAAK1F,EAAI,CAAC,EACV,KAAMA,EAAI,CAAC,EACX,QAAA0F,CACF,CACF,CACF,CACF,ECx7BO,IAAMC,EAAN,MAAMC,CAAuD,CAClE,OACA,QACA,MAMO,YAEC,UAER,YAAYC,EAAuD,CAEjE,KAAK,OAAS,CAAC,EACf,KAAK,OAAO,MAAQ,OAAO,OAAO,IAAI,EACtC,KAAK,QAAUA,GAAWC,EAC1B,KAAK,QAAQ,UAAY,KAAK,QAAQ,WAAa,IAAIC,EACvD,KAAK,UAAY,KAAK,QAAQ,UAC9B,KAAK,UAAU,QAAU,KAAK,QAC9B,KAAK,UAAU,MAAQ,KACvB,KAAK,YAAc,CAAC,EACpB,KAAK,MAAQ,CACX,OAAQ,GACR,WAAY,GACZ,IAAK,EACP,EAEA,IAAMC,EAAQ,CACZ,MAAAC,EACA,MAAOC,EAAM,OACb,OAAQC,EAAO,MACjB,EAEI,KAAK,QAAQ,UACfH,EAAM,MAAQE,EAAM,SACpBF,EAAM,OAASG,EAAO,UACb,KAAK,QAAQ,MACtBH,EAAM,MAAQE,EAAM,IAChB,KAAK,QAAQ,OACfF,EAAM,OAASG,EAAO,OAEtBH,EAAM,OAASG,EAAO,KAG1B,KAAK,UAAU,MAAQH,CACzB,CAKA,WAAW,OAAQ,CACjB,MAAO,CACL,MAAAE,EACA,OAAAC,CACF,CACF,CAKA,OAAO,IAAoDC,EAAaP,EAAuD,CAE7H,OADc,IAAID,EAAqCC,CAAO,EACjD,IAAIO,CAAG,CACtB,CAKA,OAAO,UAA0DA,EAAaP,EAAuD,CAEnI,OADc,IAAID,EAAqCC,CAAO,EACjD,aAAaO,CAAG,CAC/B,CAKA,IAAIA,EAAa,CACfA,EAAMA,EAAI,QAAQH,EAAM,eAAgB;AAAA,CAAI,EAE5C,KAAK,YAAYG,EAAK,KAAK,MAAM,EAEjC,QAASC,EAAI,EAAGA,EAAI,KAAK,YAAY,OAAQA,IAAK,CAChD,IAAMC,EAAO,KAAK,YAAYD,CAAC,EAC/B,KAAK,aAAaC,EAAK,IAAKA,EAAK,MAAM,CACzC,CACA,YAAK,YAAc,CAAC,EAEb,KAAK,MACd,CAOA,YAAYF,EAAaG,EAAkB,CAAC,EAAGC,EAAuB,GAAO,CAC3E,KAAK,UAAU,MAAQ,KACnB,KAAK,QAAQ,WACfJ,EAAMA,EAAI,QAAQH,EAAM,cAAe,MAAM,EAAE,QAAQA,EAAM,UAAW,EAAE,GAG5E,IAAIQ,EAAY,IAChB,KAAOL,GAAK,CACV,GAAIA,EAAI,OAASK,EACfA,EAAYL,EAAI,WACX,CACL,KAAK,kBAAkBA,EAAI,WAAW,CAAC,CAAC,EACxC,KACF,CAEA,IAAIM,EAEJ,GAAI,KAAK,QAAQ,YAAY,OAAO,KAAMC,IACpCD,EAAQC,EAAa,KAAK,CAAE,MAAO,IAAK,EAAGP,EAAKG,CAAM,IACxDH,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACV,IAEF,EACR,EACC,SAIF,GAAIA,EAAQ,KAAK,UAAU,MAAMN,CAAG,EAAG,CACrCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpC,IAAME,EAAYL,EAAO,GAAG,EAAE,EAC1BG,EAAM,IAAI,SAAW,GAAKE,IAAc,OAG1CA,EAAU,KAAO;AAAA,EAEjBL,EAAO,KAAKG,CAAK,EAEnB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,KAAKN,CAAG,EAAG,CACpCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpC,IAAME,EAAYL,EAAO,GAAG,EAAE,EAE1BK,GAAW,OAAS,aAAeA,GAAW,OAAS,QACzDA,EAAU,MAAQA,EAAU,IAAI,SAAS;AAAA,CAAI,EAAI,GAAK;AAAA,GAAQF,EAAM,IACpEE,EAAU,MAAQ;AAAA,EAAOF,EAAM,KAC/B,KAAK,YAAY,GAAG,EAAE,EAAG,IAAME,EAAU,MAEzCL,EAAO,KAAKG,CAAK,EAEnB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,OAAON,CAAG,EAAG,CACtCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,QAAQN,CAAG,EAAG,CACvCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,GAAGN,CAAG,EAAG,CAClCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,WAAWN,CAAG,EAAG,CAC1CA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,KAAKN,CAAG,EAAG,CACpCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,KAAKN,CAAG,EAAG,CACpCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,IAAIN,CAAG,EAAG,CACnCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpC,IAAME,EAAYL,EAAO,GAAG,EAAE,EAC1BK,GAAW,OAAS,aAAeA,GAAW,OAAS,QACzDA,EAAU,MAAQA,EAAU,IAAI,SAAS;AAAA,CAAI,EAAI,GAAK;AAAA,GAAQF,EAAM,IACpEE,EAAU,MAAQ;AAAA,EAAOF,EAAM,IAC/B,KAAK,YAAY,GAAG,EAAE,EAAG,IAAME,EAAU,MAC/B,KAAK,OAAO,MAAMF,EAAM,GAAG,IACrC,KAAK,OAAO,MAAMA,EAAM,GAAG,EAAI,CAC7B,KAAMA,EAAM,KACZ,MAAOA,EAAM,KACf,EACAH,EAAO,KAAKG,CAAK,GAEnB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,MAAMN,CAAG,EAAG,CACrCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,SAASN,CAAG,EAAG,CACxCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAIA,IAAIG,EAAST,EACb,GAAI,KAAK,QAAQ,YAAY,WAAY,CACvC,IAAIU,EAAa,IACXC,EAAUX,EAAI,MAAM,CAAC,EACvBY,EACJ,KAAK,QAAQ,WAAW,WAAW,QAASC,GAAkB,CAC5DD,EAAYC,EAAc,KAAK,CAAE,MAAO,IAAK,EAAGF,CAAO,EACnD,OAAOC,GAAc,UAAYA,GAAa,IAChDF,EAAa,KAAK,IAAIA,EAAYE,CAAS,EAE/C,CAAC,EACGF,EAAa,KAAYA,GAAc,IACzCD,EAAST,EAAI,UAAU,EAAGU,EAAa,CAAC,EAE5C,CACA,GAAI,KAAK,MAAM,MAAQJ,EAAQ,KAAK,UAAU,UAAUG,CAAM,GAAI,CAChE,IAAMD,EAAYL,EAAO,GAAG,EAAE,EAC1BC,GAAwBI,GAAW,OAAS,aAC9CA,EAAU,MAAQA,EAAU,IAAI,SAAS;AAAA,CAAI,EAAI,GAAK;AAAA,GAAQF,EAAM,IACpEE,EAAU,MAAQ;AAAA,EAAOF,EAAM,KAC/B,KAAK,YAAY,IAAI,EACrB,KAAK,YAAY,GAAG,EAAE,EAAG,IAAME,EAAU,MAEzCL,EAAO,KAAKG,CAAK,EAEnBF,EAAuBK,EAAO,SAAWT,EAAI,OAC7CA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpC,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,KAAKN,CAAG,EAAG,CACpCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpC,IAAME,EAAYL,EAAO,GAAG,EAAE,EAC1BK,GAAW,OAAS,QACtBA,EAAU,MAAQA,EAAU,IAAI,SAAS;AAAA,CAAI,EAAI,GAAK;AAAA,GAAQF,EAAM,IACpEE,EAAU,MAAQ;AAAA,EAAOF,EAAM,KAC/B,KAAK,YAAY,IAAI,EACrB,KAAK,YAAY,GAAG,EAAE,EAAG,IAAME,EAAU,MAEzCL,EAAO,KAAKG,CAAK,EAEnB,QACF,CAEA,GAAIN,EAAK,CACP,KAAK,kBAAkBA,EAAI,WAAW,CAAC,CAAC,EACxC,KACF,CACF,CAEA,YAAK,MAAM,IAAM,GACVG,CACT,CAEA,OAAOH,EAAaG,EAAkB,CAAC,EAAG,CACxC,YAAK,YAAY,KAAK,CAAE,IAAAH,EAAK,OAAAG,CAAO,CAAC,EAC9BA,CACT,CAKA,aAAaH,EAAaG,EAAkB,CAAC,EAAY,CACvD,KAAK,UAAU,MAAQ,KAEvB,IAAIW,EAAYd,EACZe,EAAgC,KAGpC,GAAI,KAAK,OAAO,MAAO,CACrB,IAAMC,EAAQ,OAAO,KAAK,KAAK,OAAO,KAAK,EAC3C,GAAIA,EAAM,OAAS,EACjB,MAAQD,EAAQ,KAAK,UAAU,MAAM,OAAO,cAAc,KAAKD,CAAS,KAAO,MACzEE,EAAM,SAASD,EAAM,CAAC,EAAE,MAAMA,EAAM,CAAC,EAAE,YAAY,GAAG,EAAI,EAAG,EAAE,CAAC,IAClED,EAAYA,EAAU,MAAM,EAAGC,EAAM,KAAK,EACtC,IAAM,IAAI,OAAOA,EAAM,CAAC,EAAE,OAAS,CAAC,EAAI,IACxCD,EAAU,MAAM,KAAK,UAAU,MAAM,OAAO,cAAc,SAAS,EAI/E,CAGA,MAAQC,EAAQ,KAAK,UAAU,MAAM,OAAO,eAAe,KAAKD,CAAS,KAAO,MAC9EA,EAAYA,EAAU,MAAM,EAAGC,EAAM,KAAK,EAAI,KAAOD,EAAU,MAAM,KAAK,UAAU,MAAM,OAAO,eAAe,SAAS,EAI3H,IAAIG,EACJ,MAAQF,EAAQ,KAAK,UAAU,MAAM,OAAO,UAAU,KAAKD,CAAS,KAAO,MACzEG,EAASF,EAAM,CAAC,EAAIA,EAAM,CAAC,EAAE,OAAS,EACtCD,EAAYA,EAAU,MAAM,EAAGC,EAAM,MAAQE,CAAM,EAAI,IAAM,IAAI,OAAOF,EAAM,CAAC,EAAE,OAASE,EAAS,CAAC,EAAI,IAAMH,EAAU,MAAM,KAAK,UAAU,MAAM,OAAO,UAAU,SAAS,EAI/KA,EAAY,KAAK,QAAQ,OAAO,cAAc,KAAK,CAAE,MAAO,IAAK,EAAGA,CAAS,GAAKA,EAElF,IAAII,EAAe,GACfC,EAAW,GACXd,EAAY,IAChB,KAAOL,GAAK,CACV,GAAIA,EAAI,OAASK,EACfA,EAAYL,EAAI,WACX,CACL,KAAK,kBAAkBA,EAAI,WAAW,CAAC,CAAC,EACxC,KACF,CAEKkB,IACHC,EAAW,IAEbD,EAAe,GAEf,IAAIZ,EAGJ,GAAI,KAAK,QAAQ,YAAY,QAAQ,KAAMC,IACrCD,EAAQC,EAAa,KAAK,CAAE,MAAO,IAAK,EAAGP,EAAKG,CAAM,IACxDH,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACV,IAEF,EACR,EACC,SAIF,GAAIA,EAAQ,KAAK,UAAU,OAAON,CAAG,EAAG,CACtCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,IAAIN,CAAG,EAAG,CACnCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,KAAKN,CAAG,EAAG,CACpCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,QAAQN,EAAK,KAAK,OAAO,KAAK,EAAG,CAC1DA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpC,IAAME,EAAYL,EAAO,GAAG,EAAE,EAC1BG,EAAM,OAAS,QAAUE,GAAW,OAAS,QAC/CA,EAAU,KAAOF,EAAM,IACvBE,EAAU,MAAQF,EAAM,MAExBH,EAAO,KAAKG,CAAK,EAEnB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,SAASN,EAAKc,EAAWK,CAAQ,EAAG,CAC7DnB,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,SAASN,CAAG,EAAG,CACxCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,GAAGN,CAAG,EAAG,CAClCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,IAAIN,EAAKc,EAAWK,CAAQ,EAAG,CACxDnB,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAIA,EAAQ,KAAK,UAAU,SAASN,CAAG,EAAG,CACxCA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAGA,GAAI,CAAC,KAAK,MAAM,SAAWA,EAAQ,KAAK,UAAU,IAAIN,CAAG,GAAI,CAC3DA,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EACpCH,EAAO,KAAKG,CAAK,EACjB,QACF,CAIA,IAAIG,EAAST,EACb,GAAI,KAAK,QAAQ,YAAY,YAAa,CACxC,IAAIU,EAAa,IACXC,EAAUX,EAAI,MAAM,CAAC,EACvBY,EACJ,KAAK,QAAQ,WAAW,YAAY,QAASC,GAAkB,CAC7DD,EAAYC,EAAc,KAAK,CAAE,MAAO,IAAK,EAAGF,CAAO,EACnD,OAAOC,GAAc,UAAYA,GAAa,IAChDF,EAAa,KAAK,IAAIA,EAAYE,CAAS,EAE/C,CAAC,EACGF,EAAa,KAAYA,GAAc,IACzCD,EAAST,EAAI,UAAU,EAAGU,EAAa,CAAC,EAE5C,CACA,GAAIJ,EAAQ,KAAK,UAAU,WAAWG,CAAM,EAAG,CAC7CT,EAAMA,EAAI,UAAUM,EAAM,IAAI,MAAM,EAChCA,EAAM,IAAI,MAAM,EAAE,IAAM,MAC1Ba,EAAWb,EAAM,IAAI,MAAM,EAAE,GAE/BY,EAAe,GACf,IAAMV,EAAYL,EAAO,GAAG,EAAE,EAC1BK,GAAW,OAAS,QACtBA,EAAU,KAAOF,EAAM,IACvBE,EAAU,MAAQF,EAAM,MAExBH,EAAO,KAAKG,CAAK,EAEnB,QACF,CAEA,GAAIN,EAAK,CACP,KAAK,kBAAkBA,EAAI,WAAW,CAAC,CAAC,EACxC,KACF,CACF,CAEA,OAAOG,CACT,CAEQ,kBAAkBiB,EAAc,CACtC,IAAMC,EAAS,0BAA4BD,EAC3C,GAAI,KAAK,QAAQ,OACf,QAAQ,MAAMC,CAAM,MAEpB,OAAM,IAAI,MAAMA,CAAM,CAE1B,CACF,ECheO,IAAMC,EAAN,KAAgE,CACrE,QACA,OACA,YAAYC,EAAuD,CACjE,KAAK,QAAUA,GAAWC,CAC5B,CAEA,MAAMC,EAAqC,CACzC,MAAO,EACT,CAEA,KAAK,CAAE,KAAAC,EAAM,KAAAC,EAAM,QAAAC,CAAQ,EAAgC,CACzD,IAAMC,GAAcF,GAAQ,IAAI,MAAMG,EAAM,aAAa,IAAI,CAAC,EAExDC,EAAOL,EAAK,QAAQI,EAAM,cAAe,EAAE,EAAI;AAAA,EAErD,OAAKD,EAME,8BACHG,EAAmBH,CAAU,EAC7B,MACCD,EAAUG,EAAOC,EAAmBD,EAAM,EAAI,GAC/C;AAAA,EATK,eACFH,EAAUG,EAAOC,EAAmBD,EAAM,EAAI,GAC/C;AAAA,CAQR,CAEA,WAAW,CAAE,OAAAE,CAAO,EAAsC,CAExD,MAAO;AAAA,EADM,KAAK,OAAO,MAAMA,CAAM,CACT;AAAA,CAC9B,CAEA,KAAK,CAAE,KAAAP,CAAK,EAA6C,CACvD,OAAOA,CACT,CAEA,IAAID,EAAmC,CACrC,MAAO,EACT,CAEA,QAAQ,CAAE,OAAAQ,EAAQ,MAAAC,CAAM,EAAmC,CACzD,MAAO,KAAKA,CAAK,IAAI,KAAK,OAAO,YAAYD,CAAM,CAAC,MAAMC,CAAK;AAAA,CACjE,CAEA,GAAGT,EAAkC,CACnC,MAAO;AAAA,CACT,CAEA,KAAKA,EAAoC,CACvC,IAAMU,EAAUV,EAAM,QAChBW,EAAQX,EAAM,MAEhBY,EAAO,GACX,QAASC,EAAI,EAAGA,EAAIb,EAAM,MAAM,OAAQa,IAAK,CAC3C,IAAMC,EAAOd,EAAM,MAAMa,CAAC,EAC1BD,GAAQ,KAAK,SAASE,CAAI,CAC5B,CAEA,IAAMC,EAAOL,EAAU,KAAO,KACxBM,EAAaN,GAAWC,IAAU,EAAM,WAAaA,EAAQ,IAAO,GAC1E,MAAO,IAAMI,EAAOC,EAAY;AAAA,EAAQJ,EAAO,KAAOG,EAAO;AAAA,CAC/D,CAEA,SAASD,EAAuC,CAC9C,MAAO,OAAO,KAAK,OAAO,MAAMA,EAAK,MAAM,CAAC;AAAA,CAC9C,CAEA,SAAS,CAAE,QAAAG,CAAQ,EAAoC,CACrD,MAAO,WACFA,EAAU,cAAgB,IAC3B,+BACN,CAEA,UAAU,CAAE,OAAAT,CAAO,EAAqC,CACtD,MAAO,MAAM,KAAK,OAAO,YAAYA,CAAM,CAAC;AAAA,CAC9C,CAEA,MAAMR,EAAqC,CACzC,IAAIkB,EAAS,GAGTC,EAAO,GACX,QAASN,EAAI,EAAGA,EAAIb,EAAM,OAAO,OAAQa,IACvCM,GAAQ,KAAK,UAAUnB,EAAM,OAAOa,CAAC,CAAC,EAExCK,GAAU,KAAK,SAAS,CAAE,KAAMC,CAAqB,CAAC,EAEtD,IAAIP,EAAO,GACX,QAASC,EAAI,EAAGA,EAAIb,EAAM,KAAK,OAAQa,IAAK,CAC1C,IAAMO,EAAMpB,EAAM,KAAKa,CAAC,EAExBM,EAAO,GACP,QAASE,EAAI,EAAGA,EAAID,EAAI,OAAQC,IAC9BF,GAAQ,KAAK,UAAUC,EAAIC,CAAC,CAAC,EAG/BT,GAAQ,KAAK,SAAS,CAAE,KAAMO,CAAqB,CAAC,CACtD,CACA,OAAIP,IAAMA,EAAO,UAAUA,CAAI,YAExB;AAAA;AAAA,EAEHM,EACA;AAAA,EACAN,EACA;AAAA,CACN,CAEA,SAAS,CAAE,KAAAX,CAAK,EAAkD,CAChE,MAAO;AAAA,EAASA,CAAI;AAAA,CACtB,CAEA,UAAUD,EAAyC,CACjD,IAAMsB,EAAU,KAAK,OAAO,YAAYtB,EAAM,MAAM,EAC9Ce,EAAOf,EAAM,OAAS,KAAO,KAInC,OAHYA,EAAM,MACd,IAAIe,CAAI,WAAWf,EAAM,KAAK,KAC9B,IAAIe,CAAI,KACCO,EAAU,KAAKP,CAAI;AAAA,CAClC,CAKA,OAAO,CAAE,OAAAP,CAAO,EAAkC,CAChD,MAAO,WAAW,KAAK,OAAO,YAAYA,CAAM,CAAC,WACnD,CAEA,GAAG,CAAE,OAAAA,CAAO,EAA8B,CACxC,MAAO,OAAO,KAAK,OAAO,YAAYA,CAAM,CAAC,OAC/C,CAEA,SAAS,CAAE,KAAAP,CAAK,EAAoC,CAClD,MAAO,SAASM,EAAmBN,EAAM,EAAI,CAAC,SAChD,CAEA,GAAGD,EAAkC,CACnC,MAAO,MACT,CAEA,IAAI,CAAE,OAAAQ,CAAO,EAA+B,CAC1C,MAAO,QAAQ,KAAK,OAAO,YAAYA,CAAM,CAAC,QAChD,CAEA,KAAK,CAAE,KAAAe,EAAM,MAAAC,EAAO,OAAAhB,CAAO,EAAgC,CACzD,IAAMP,EAAO,KAAK,OAAO,YAAYO,CAAM,EACrCiB,EAAYC,EAASH,CAAI,EAC/B,GAAIE,IAAc,KAChB,OAAOxB,EAETsB,EAAOE,EACP,IAAIE,EAAM,YAAcJ,EAAO,IAC/B,OAAIC,IACFG,GAAO,WAAcpB,EAAmBiB,CAAK,EAAK,KAEpDG,GAAO,IAAM1B,EAAO,OACb0B,CACT,CAEA,MAAM,CAAE,KAAAJ,EAAM,MAAAC,EAAO,KAAAvB,EAAM,OAAAO,CAAO,EAAiC,CAC7DA,IACFP,EAAO,KAAK,OAAO,YAAYO,EAAQ,KAAK,OAAO,YAAY,GAEjE,IAAMiB,EAAYC,EAASH,CAAI,EAC/B,GAAIE,IAAc,KAChB,OAAOlB,EAAmBN,CAAI,EAEhCsB,EAAOE,EAEP,IAAIE,EAAM,aAAaJ,CAAI,UAAUhB,EAAmBN,CAAI,CAAC,IAC7D,OAAIuB,IACFG,GAAO,WAAWpB,EAAmBiB,CAAK,CAAC,KAE7CG,GAAO,IACAA,CACT,CAEA,KAAK3B,EAAoD,CACvD,MAAO,WAAYA,GAASA,EAAM,OAC9B,KAAK,OAAO,YAAYA,EAAM,MAAM,EACnC,YAAaA,GAASA,EAAM,QAAUA,EAAM,KAAyBO,EAAmBP,EAAM,IAAI,CACzG,CACF,EC/LO,IAAM4B,EAAN,KAA6C,CAElD,OAAO,CAAE,KAAAC,CAAK,EAAkC,CAC9C,OAAOA,CACT,CAEA,GAAG,CAAE,KAAAA,CAAK,EAA8B,CACtC,OAAOA,CACT,CAEA,SAAS,CAAE,KAAAA,CAAK,EAAoC,CAClD,OAAOA,CACT,CAEA,IAAI,CAAE,KAAAA,CAAK,EAA+B,CACxC,OAAOA,CACT,CAEA,KAAK,CAAE,KAAAA,CAAK,EAA6C,CACvD,OAAOA,CACT,CAEA,KAAK,CAAE,KAAAA,CAAK,EAA6D,CACvE,OAAOA,CACT,CAEA,KAAK,CAAE,KAAAA,CAAK,EAAgC,CAC1C,MAAO,GAAKA,CACd,CAEA,MAAM,CAAE,KAAAA,CAAK,EAAiC,CAC5C,MAAO,GAAKA,CACd,CAEA,IAAqB,CACnB,MAAO,EACT,CAEA,SAAS,CAAE,IAAAC,CAAI,EAAoC,CACjD,OAAOA,CACT,CACF,ECtCO,IAAMC,EAAN,MAAMC,CAAwD,CACnE,QACA,SACA,aACA,YAAYC,EAAuD,CACjE,KAAK,QAAUA,GAAWC,EAC1B,KAAK,QAAQ,SAAW,KAAK,QAAQ,UAAY,IAAIC,EACrD,KAAK,SAAW,KAAK,QAAQ,SAC7B,KAAK,SAAS,QAAU,KAAK,QAC7B,KAAK,SAAS,OAAS,KACvB,KAAK,aAAe,IAAIC,CAC1B,CAKA,OAAO,MAAsDC,EAAiBJ,EAAuD,CAEnI,OADe,IAAID,EAAsCC,CAAO,EAClD,MAAMI,CAAM,CAC5B,CAKA,OAAO,YAA4DA,EAAiBJ,EAAuD,CAEzI,OADe,IAAID,EAAsCC,CAAO,EAClD,YAAYI,CAAM,CAClC,CAKA,MAAMA,EAA+B,CACnC,KAAK,SAAS,OAAS,KACvB,IAAIC,EAAM,GAEV,QAASC,EAAI,EAAGA,EAAIF,EAAO,OAAQE,IAAK,CACtC,IAAMC,EAAWH,EAAOE,CAAC,EAGzB,GAAI,KAAK,QAAQ,YAAY,YAAYC,EAAS,IAAI,EAAG,CACvD,IAAMC,EAAeD,EACfE,EAAM,KAAK,QAAQ,WAAW,UAAUD,EAAa,IAAI,EAAE,KAAK,CAAE,OAAQ,IAAK,EAAGA,CAAY,EACpG,GAAIC,IAAQ,IAAS,CAAC,CAAC,QAAS,KAAM,UAAW,OAAQ,QAAS,aAAc,OAAQ,OAAQ,MAAO,YAAa,MAAM,EAAE,SAASD,EAAa,IAAI,EAAG,CACvJH,GAAOI,GAAO,GACd,QACF,CACF,CAEA,IAAMC,EAAQH,EAEd,OAAQG,EAAM,KAAM,CAClB,IAAK,QAAS,CACZL,GAAO,KAAK,SAAS,MAAMK,CAAK,EAChC,KACF,CACA,IAAK,KAAM,CACTL,GAAO,KAAK,SAAS,GAAGK,CAAK,EAC7B,KACF,CACA,IAAK,UAAW,CACdL,GAAO,KAAK,SAAS,QAAQK,CAAK,EAClC,KACF,CACA,IAAK,OAAQ,CACXL,GAAO,KAAK,SAAS,KAAKK,CAAK,EAC/B,KACF,CACA,IAAK,QAAS,CACZL,GAAO,KAAK,SAAS,MAAMK,CAAK,EAChC,KACF,CACA,IAAK,aAAc,CACjBL,GAAO,KAAK,SAAS,WAAWK,CAAK,EACrC,KACF,CACA,IAAK,OAAQ,CACXL,GAAO,KAAK,SAAS,KAAKK,CAAK,EAC/B,KACF,CACA,IAAK,WAAY,CACfL,GAAO,KAAK,SAAS,SAASK,CAAK,EACnC,KACF,CACA,IAAK,OAAQ,CACXL,GAAO,KAAK,SAAS,KAAKK,CAAK,EAC/B,KACF,CACA,IAAK,MAAO,CACVL,GAAO,KAAK,SAAS,IAAIK,CAAK,EAC9B,KACF,CACA,IAAK,YAAa,CAChBL,GAAO,KAAK,SAAS,UAAUK,CAAK,EACpC,KACF,CACA,IAAK,OAAQ,CACXL,GAAO,KAAK,SAAS,KAAKK,CAAK,EAC/B,KACF,CAEA,QAAS,CACP,IAAMC,EAAS,eAAiBD,EAAM,KAAO,wBAC7C,GAAI,KAAK,QAAQ,OACf,eAAQ,MAAMC,CAAM,EACb,GAEP,MAAM,IAAI,MAAMA,CAAM,CAE1B,CACF,CACF,CAEA,OAAON,CACT,CAKA,YAAYD,EAAiBQ,EAAoF,KAAK,SAAwB,CAC5I,KAAK,SAAS,OAAS,KACvB,IAAIP,EAAM,GAEV,QAASC,EAAI,EAAGA,EAAIF,EAAO,OAAQE,IAAK,CACtC,IAAMC,EAAWH,EAAOE,CAAC,EAGzB,GAAI,KAAK,QAAQ,YAAY,YAAYC,EAAS,IAAI,EAAG,CACvD,IAAME,EAAM,KAAK,QAAQ,WAAW,UAAUF,EAAS,IAAI,EAAE,KAAK,CAAE,OAAQ,IAAK,EAAGA,CAAQ,EAC5F,GAAIE,IAAQ,IAAS,CAAC,CAAC,SAAU,OAAQ,OAAQ,QAAS,SAAU,KAAM,WAAY,KAAM,MAAO,MAAM,EAAE,SAASF,EAAS,IAAI,EAAG,CAClIF,GAAOI,GAAO,GACd,QACF,CACF,CAEA,IAAMC,EAAQH,EAEd,OAAQG,EAAM,KAAM,CAClB,IAAK,SAAU,CACbL,GAAOO,EAAS,KAAKF,CAAK,EAC1B,KACF,CACA,IAAK,OAAQ,CACXL,GAAOO,EAAS,KAAKF,CAAK,EAC1B,KACF,CACA,IAAK,OAAQ,CACXL,GAAOO,EAAS,KAAKF,CAAK,EAC1B,KACF,CACA,IAAK,QAAS,CACZL,GAAOO,EAAS,MAAMF,CAAK,EAC3B,KACF,CACA,IAAK,WAAY,CACfL,GAAOO,EAAS,SAASF,CAAK,EAC9B,KACF,CACA,IAAK,SAAU,CACbL,GAAOO,EAAS,OAAOF,CAAK,EAC5B,KACF,CACA,IAAK,KAAM,CACTL,GAAOO,EAAS,GAAGF,CAAK,EACxB,KACF,CACA,IAAK,WAAY,CACfL,GAAOO,EAAS,SAASF,CAAK,EAC9B,KACF,CACA,IAAK,KAAM,CACTL,GAAOO,EAAS,GAAGF,CAAK,EACxB,KACF,CACA,IAAK,MAAO,CACVL,GAAOO,EAAS,IAAIF,CAAK,EACzB,KACF,CACA,IAAK,OAAQ,CACXL,GAAOO,EAAS,KAAKF,CAAK,EAC1B,KACF,CACA,QAAS,CACP,IAAMC,EAAS,eAAiBD,EAAM,KAAO,wBAC7C,GAAI,KAAK,QAAQ,OACf,eAAQ,MAAMC,CAAM,EACb,GAEP,MAAM,IAAI,MAAMA,CAAM,CAE1B,CACF,CACF,CACA,OAAON,CACT,CACF,ECtMO,IAAMQ,EAAN,KAA6D,CAClE,QACA,MAEA,YAAYC,EAAuD,CACjE,KAAK,QAAUA,GAAWC,CAC5B,CAEA,OAAO,iBAAmB,IAAI,IAAI,CAChC,aACA,cACA,mBACA,cACF,CAAC,EAED,OAAO,6BAA+B,IAAI,IAAI,CAC5C,aACA,cACA,kBACF,CAAC,EAKD,WAAWC,EAAkB,CAC3B,OAAOA,CACT,CAKA,YAAYC,EAAoB,CAC9B,OAAOA,CACT,CAKA,iBAAiBC,EAA8B,CAC7C,OAAOA,CACT,CAKA,aAAaC,EAAa,CACxB,OAAOA,CACT,CAKA,aAAaC,EAAQ,KAAK,MAAO,CAC/B,OAAOA,EAAQC,EAAO,IAAMA,EAAO,SACrC,CAKA,cAAcD,EAAQ,KAAK,MAAO,CAChC,OAAOA,EAAQE,EAAQ,MAAsCA,EAAQ,WACvE,CACF,ECpDO,IAAMC,EAAN,KAA6D,CAClE,SAAWC,EAA2C,EACtD,QAAU,KAAK,WAEf,MAAQ,KAAK,cAAc,EAAI,EAC/B,YAAc,KAAK,cAAc,EAAK,EAEtC,OAASC,EACT,SAAWC,EACX,aAAeC,EACf,MAAQC,EACR,UAAYC,EACZ,MAAQC,EAER,eAAeC,EAAuD,CACpE,KAAK,IAAI,GAAGA,CAAI,CAClB,CAKA,WAAWC,EAA8BC,EAA2D,CAClG,IAAIC,EAAyB,CAAC,EAC9B,QAAWC,KAASH,EAElB,OADAE,EAASA,EAAO,OAAOD,EAAS,KAAK,KAAME,CAAK,CAAC,EACzCA,EAAM,KAAM,CAClB,IAAK,QAAS,CACZ,IAAMC,EAAaD,EACnB,QAAWE,KAAQD,EAAW,OAC5BF,EAASA,EAAO,OAAO,KAAK,WAAWG,EAAK,OAAQJ,CAAQ,CAAC,EAE/D,QAAWK,KAAOF,EAAW,KAC3B,QAAWC,KAAQC,EACjBJ,EAASA,EAAO,OAAO,KAAK,WAAWG,EAAK,OAAQJ,CAAQ,CAAC,EAGjE,KACF,CACA,IAAK,OAAQ,CACX,IAAMM,EAAYJ,EAClBD,EAASA,EAAO,OAAO,KAAK,WAAWK,EAAU,MAAON,CAAQ,CAAC,EACjE,KACF,CACA,QAAS,CACP,IAAMO,EAAeL,EACjB,KAAK,SAAS,YAAY,cAAcK,EAAa,IAAI,EAC3D,KAAK,SAAS,WAAW,YAAYA,EAAa,IAAI,EAAE,QAASC,GAAgB,CAC/E,IAAMT,EAASQ,EAAaC,CAAW,EAAE,KAAK,GAAQ,EACtDP,EAASA,EAAO,OAAO,KAAK,WAAWF,EAAQC,CAAQ,CAAC,CAC1D,CAAC,EACQO,EAAa,SACtBN,EAASA,EAAO,OAAO,KAAK,WAAWM,EAAa,OAAQP,CAAQ,CAAC,EAEzE,CACF,CAEF,OAAOC,CACT,CAEA,OAAOH,EAAuD,CAC5D,IAAMW,EAAwE,KAAK,SAAS,YAAc,CAAE,UAAW,CAAC,EAAG,YAAa,CAAC,CAAE,EAE3I,OAAAX,EAAK,QAASY,GAAS,CAErB,IAAMC,EAAO,CAAE,GAAGD,CAAK,EA4DvB,GAzDAC,EAAK,MAAQ,KAAK,SAAS,OAASA,EAAK,OAAS,GAG9CD,EAAK,aACPA,EAAK,WAAW,QAASE,GAAQ,CAC/B,GAAI,CAACA,EAAI,KACP,MAAM,IAAI,MAAM,yBAAyB,EAE3C,GAAI,aAAcA,EAAK,CACrB,IAAMC,EAAeJ,EAAW,UAAUG,EAAI,IAAI,EAC9CC,EAEFJ,EAAW,UAAUG,EAAI,IAAI,EAAI,YAAYd,EAAM,CACjD,IAAIgB,EAAMF,EAAI,SAAS,MAAM,KAAMd,CAAI,EACvC,OAAIgB,IAAQ,KACVA,EAAMD,EAAa,MAAM,KAAMf,CAAI,GAE9BgB,CACT,EAEAL,EAAW,UAAUG,EAAI,IAAI,EAAIA,EAAI,QAEzC,CACA,GAAI,cAAeA,EAAK,CACtB,GAAI,CAACA,EAAI,OAAUA,EAAI,QAAU,SAAWA,EAAI,QAAU,SACxD,MAAM,IAAI,MAAM,6CAA6C,EAE/D,IAAMG,EAAWN,EAAWG,EAAI,KAAK,EACjCG,EACFA,EAAS,QAAQH,EAAI,SAAS,EAE9BH,EAAWG,EAAI,KAAK,EAAI,CAACA,EAAI,SAAS,EAEpCA,EAAI,QACFA,EAAI,QAAU,QACZH,EAAW,WACbA,EAAW,WAAW,KAAKG,EAAI,KAAK,EAEpCH,EAAW,WAAa,CAACG,EAAI,KAAK,EAE3BA,EAAI,QAAU,WACnBH,EAAW,YACbA,EAAW,YAAY,KAAKG,EAAI,KAAK,EAErCH,EAAW,YAAc,CAACG,EAAI,KAAK,GAI3C,CACI,gBAAiBA,GAAOA,EAAI,cAC9BH,EAAW,YAAYG,EAAI,IAAI,EAAIA,EAAI,YAE3C,CAAC,EACDD,EAAK,WAAaF,GAIhBC,EAAK,SAAU,CACjB,IAAMM,EAAW,KAAK,SAAS,UAAY,IAAIvB,EAAwC,KAAK,QAAQ,EACpG,QAAWwB,KAAQP,EAAK,SAAU,CAChC,GAAI,EAAEO,KAAQD,GACZ,MAAM,IAAI,MAAM,aAAaC,CAAI,kBAAkB,EAErD,GAAI,CAAC,UAAW,QAAQ,EAAE,SAASA,CAAI,EAErC,SAEF,IAAMC,EAAeD,EACfE,EAAeT,EAAK,SAASQ,CAAY,EACzCL,EAAeG,EAASE,CAAY,EAE1CF,EAASE,CAAY,EAAI,IAAIpB,IAAoB,CAC/C,IAAIgB,EAAMK,EAAa,MAAMH,EAAUlB,CAAI,EAC3C,OAAIgB,IAAQ,KACVA,EAAMD,EAAa,MAAMG,EAAUlB,CAAI,GAEjCgB,GAAO,EACjB,CACF,CACAH,EAAK,SAAWK,CAClB,CACA,GAAIN,EAAK,UAAW,CAClB,IAAMU,EAAY,KAAK,SAAS,WAAa,IAAIxB,EAAyC,KAAK,QAAQ,EACvG,QAAWqB,KAAQP,EAAK,UAAW,CACjC,GAAI,EAAEO,KAAQG,GACZ,MAAM,IAAI,MAAM,cAAcH,CAAI,kBAAkB,EAEtD,GAAI,CAAC,UAAW,QAAS,OAAO,EAAE,SAASA,CAAI,EAE7C,SAEF,IAAMI,EAAgBJ,EAChBK,EAAgBZ,EAAK,UAAUW,CAAa,EAC5CE,EAAgBH,EAAUC,CAAa,EAG7CD,EAAUC,CAAa,EAAI,IAAIvB,IAAoB,CACjD,IAAIgB,EAAMQ,EAAc,MAAMF,EAAWtB,CAAI,EAC7C,OAAIgB,IAAQ,KACVA,EAAMS,EAAc,MAAMH,EAAWtB,CAAI,GAEpCgB,CACT,CACF,CACAH,EAAK,UAAYS,CACnB,CAGA,GAAIV,EAAK,MAAO,CACd,IAAMc,EAAQ,KAAK,SAAS,OAAS,IAAI3B,EACzC,QAAWoB,KAAQP,EAAK,MAAO,CAC7B,GAAI,EAAEO,KAAQO,GACZ,MAAM,IAAI,MAAM,SAASP,CAAI,kBAAkB,EAEjD,GAAI,CAAC,UAAW,OAAO,EAAE,SAASA,CAAI,EAEpC,SAEF,IAAMQ,EAAYR,EACZS,EAAYhB,EAAK,MAAMe,CAAS,EAChCE,EAAWH,EAAMC,CAAS,EAC5B5B,EAAO,iBAAiB,IAAIoB,CAAI,EAElCO,EAAMC,CAAS,EAAKG,GAAiB,CACnC,GAAI,KAAK,SAAS,OAAS/B,EAAO,6BAA6B,IAAIoB,CAAI,EACrE,OAAQ,SAAW,CACjB,IAAMH,EAAM,MAAMY,EAAU,KAAKF,EAAOI,CAAG,EAC3C,OAAOD,EAAS,KAAKH,EAAOV,CAAG,CACjC,GAAG,EAGL,IAAMA,EAAMY,EAAU,KAAKF,EAAOI,CAAG,EACrC,OAAOD,EAAS,KAAKH,EAAOV,CAAG,CACjC,EAGAU,EAAMC,CAAS,EAAI,IAAI3B,IAAoB,CACzC,GAAI,KAAK,SAAS,MAChB,OAAQ,SAAW,CACjB,IAAIgB,EAAM,MAAMY,EAAU,MAAMF,EAAO1B,CAAI,EAC3C,OAAIgB,IAAQ,KACVA,EAAM,MAAMa,EAAS,MAAMH,EAAO1B,CAAI,GAEjCgB,CACT,GAAG,EAGL,IAAIA,EAAMY,EAAU,MAAMF,EAAO1B,CAAI,EACrC,OAAIgB,IAAQ,KACVA,EAAMa,EAAS,MAAMH,EAAO1B,CAAI,GAE3BgB,CACT,CAEJ,CACAH,EAAK,MAAQa,CACf,CAGA,GAAId,EAAK,WAAY,CACnB,IAAMmB,EAAa,KAAK,SAAS,WAC3BC,EAAiBpB,EAAK,WAC5BC,EAAK,WAAa,SAAST,EAAO,CAChC,IAAID,EAAyB,CAAC,EAC9B,OAAAA,EAAO,KAAK6B,EAAe,KAAK,KAAM5B,CAAK,CAAC,EACxC2B,IACF5B,EAASA,EAAO,OAAO4B,EAAW,KAAK,KAAM3B,CAAK,CAAC,GAE9CD,CACT,CACF,CAEA,KAAK,SAAW,CAAE,GAAG,KAAK,SAAU,GAAGU,CAAK,CAC9C,CAAC,EAEM,IACT,CAEA,WAAWoB,EAAkD,CAC3D,YAAK,SAAW,CAAE,GAAG,KAAK,SAAU,GAAGA,CAAI,EACpC,IACT,CAEA,MAAMC,EAAaC,EAAuD,CACxE,OAAOtC,EAAO,IAAIqC,EAAKC,GAAW,KAAK,QAAQ,CACjD,CAEA,OAAOlC,EAAiBkC,EAAuD,CAC7E,OAAOzC,EAAQ,MAAoCO,EAAQkC,GAAW,KAAK,QAAQ,CACrF,CAEQ,cAAcC,EAAoB,CAuExC,MA/D+B,CAACF,EAAaC,IAAsE,CACjH,IAAME,EAAU,CAAE,GAAGF,CAAQ,EACvBF,EAAM,CAAE,GAAG,KAAK,SAAU,GAAGI,CAAQ,EAErCC,EAAa,KAAK,QAAQ,CAAC,CAACL,EAAI,OAAQ,CAAC,CAACA,EAAI,KAAK,EAGzD,GAAI,KAAK,SAAS,QAAU,IAAQI,EAAQ,QAAU,GACpD,OAAOC,EAAW,IAAI,MAAM,oIAAoI,CAAC,EAInK,GAAI,OAAOJ,EAAQ,KAAeA,IAAQ,KACxC,OAAOI,EAAW,IAAI,MAAM,gDAAgD,CAAC,EAE/E,GAAI,OAAOJ,GAAQ,SACjB,OAAOI,EAAW,IAAI,MAAM,wCACxB,OAAO,UAAU,SAAS,KAAKJ,CAAG,EAAI,mBAAmB,CAAC,EAQhE,GALID,EAAI,QACNA,EAAI,MAAM,QAAUA,EACpBA,EAAI,MAAM,MAAQG,GAGhBH,EAAI,MACN,OAAQ,SAAW,CACjB,IAAMM,EAAeN,EAAI,MAAQ,MAAMA,EAAI,MAAM,WAAWC,CAAG,EAAIA,EAE7DjC,EAAS,MADDgC,EAAI,MAAQ,MAAMA,EAAI,MAAM,aAAaG,CAAS,EAAKA,EAAYvC,EAAO,IAAMA,EAAO,WAC1E0C,EAAcN,CAAG,EACtCO,EAAkBP,EAAI,MAAQ,MAAMA,EAAI,MAAM,iBAAiBhC,CAAM,EAAIA,EAC3EgC,EAAI,YACN,MAAM,QAAQ,IAAI,KAAK,WAAWO,EAAiBP,EAAI,UAAU,CAAC,EAGpE,IAAMQ,EAAO,MADER,EAAI,MAAQ,MAAMA,EAAI,MAAM,cAAcG,CAAS,EAAKA,EAAY1C,EAAQ,MAAQA,EAAQ,aACjF8C,EAAiBP,CAAG,EAC9C,OAAOA,EAAI,MAAQ,MAAMA,EAAI,MAAM,YAAYQ,CAAI,EAAIA,CACzD,GAAG,EAAE,MAAMH,CAAU,EAGvB,GAAI,CACEL,EAAI,QACNC,EAAMD,EAAI,MAAM,WAAWC,CAAG,GAGhC,IAAIjC,GADUgC,EAAI,MAAQA,EAAI,MAAM,aAAaG,CAAS,EAAKA,EAAYvC,EAAO,IAAMA,EAAO,WAC5EqC,EAAKD,CAAG,EACvBA,EAAI,QACNhC,EAASgC,EAAI,MAAM,iBAAiBhC,CAAM,GAExCgC,EAAI,YACN,KAAK,WAAWhC,EAAQgC,EAAI,UAAU,EAGxC,IAAIQ,GADWR,EAAI,MAAQA,EAAI,MAAM,cAAcG,CAAS,EAAKA,EAAY1C,EAAQ,MAAQA,EAAQ,aACnFO,EAAQgC,CAAG,EAC7B,OAAIA,EAAI,QACNQ,EAAOR,EAAI,MAAM,YAAYQ,CAAI,GAE5BA,CACT,OAAQC,EAAG,CACT,OAAOJ,EAAWI,CAAU,CAC9B,CACF,CAGF,CAEQ,QAAQC,EAAiBC,EAAgB,CAC/C,OAAQF,GAAuC,CAG7C,GAFAA,EAAE,SAAW;AAAA,2DAETC,EAAQ,CACV,IAAME,EAAM,iCACRC,EAAmBJ,EAAE,QAAU,GAAI,EAAI,EACvC,SACJ,OAAIE,EACK,QAAQ,QAAQC,CAAG,EAErBA,CACT,CAEA,GAAID,EACF,OAAO,QAAQ,OAAOF,CAAC,EAEzB,MAAMA,CACR,CACF,CACF,EChWA,IAAMK,EAAiB,IAAIC,EAqBpB,SAASC,EAAOC,EAAaC,EAAsD,CACxF,OAAOJ,EAAe,MAAMG,EAAKC,CAAG,CACtC,CAOAF,EAAO,QACLA,EAAO,WAAa,SAASG,EAAwB,CACnD,OAAAL,EAAe,WAAWK,CAAO,EACjCH,EAAO,SAAWF,EAAe,SACjCM,EAAeJ,EAAO,QAAQ,EACvBA,CACT,EAKFA,EAAO,YAAcK,EAErBL,EAAO,SAAWM,EAMlBN,EAAO,IAAM,YAAYO,EAAyB,CAChD,OAAAT,EAAe,IAAI,GAAGS,CAAI,EAC1BP,EAAO,SAAWF,EAAe,SACjCM,EAAeJ,EAAO,QAAQ,EACvBA,CACT,EAMAA,EAAO,WAAa,SAASQ,EAA8BC,EAA2D,CACpH,OAAOX,EAAe,WAAWU,EAAQC,CAAQ,CACnD,EASAT,EAAO,YAAcF,EAAe,YAKpCE,EAAO,OAASU,EAChBV,EAAO,OAASU,EAAQ,MACxBV,EAAO,SAAWW,EAClBX,EAAO,aAAeY,EACtBZ,EAAO,MAAQa,EACfb,EAAO,MAAQa,EAAO,IACtBb,EAAO,UAAYc,EACnBd,EAAO,MAAQe,EACff,EAAO,MAAQA,EAER,IAAMG,GAAUH,EAAO,QACjBgB,GAAahB,EAAO,WACpBiB,GAAMjB,EAAO,IACbkB,GAAalB,EAAO,WACpBmB,GAAcnB,EAAO,YACrBoB,GAAQpB,EACRqB,GAASX,EAAQ,MACjBY,GAAQT,EAAO", + "names": ["_getDefaults", "_defaults", "changeDefaults", "newDefaults", "noopTest", "cachedIndentRegex", "createRegex", "cache", "indent", "cacheIndex", "regex", "edit", "opt", "source", "obj", "name", "val", "valSource", "other", "supportsLookbehind", "a", "bull", "newline", "blockCode", "fences", "hr", "heading", "bullet", "lheadingCore", "lheading", "lheadingGfm", "_paragraph", "blockText", "_blockLabel", "def", "list", "_tag", "_comment", "html", "paragraph", "blockquote", "blockNormal", "gfmTable", "blockGfm", "blockPedantic", "escape", "inlineCode", "br", "inlineText", "_punctuation", "_punctuationOrSpace", "_notPunctuationOrSpace", "punctuation", "_punctuationGfmStrongEm", "_punctuationOrSpaceGfmStrongEm", "_notPunctuationOrSpaceGfmStrongEm", "blockSkip", "emStrongLDelimCore", "emStrongLDelim", "emStrongLDelimGfm", "emStrongRDelimAstCore", "emStrongRDelimAst", "emStrongRDelimAstGfm", "emStrongRDelimUnd", "delLDelim", "delRDelimCore", "delRDelim", "anyPunctuation", "autolink", "_inlineComment", "tag", "_inlineLabel", "link", "reflink", "nolink", "reflinkSearch", "_caseInsensitiveProtocol", "inlineNormal", "inlinePedantic", "inlineGfm", "inlineBreaks", "block", "inline", "escapeReplacements", "getEscapeReplacement", "ch", "escapeHtmlEntities", "html", "encode", "other", "cleanUrl", "href", "splitCells", "tableRow", "count", "row", "match", "offset", "str", "escaped", "curr", "cells", "i", "rtrim", "c", "invert", "l", "suffLen", "currChar", "trimTrailingBlankLines", "lines", "end", "findClosingBracket", "b", "level", "expandTabs", "line", "indent", "col", "expanded", "char", "added", "outputLink", "cap", "link", "raw", "lexer", "rules", "href", "title", "text", "token", "indentCodeCompensation", "matchIndentToCode", "indentToCode", "node", "matchIndentInNode", "indentInNode", "_Tokenizer", "options", "_defaults", "src", "trimTrailingBlankLines", "trimmed", "rtrim", "lines", "tokens", "inBlockquote", "currentLines", "i", "currentRaw", "currentText", "top", "lastToken", "oldToken", "newText", "newToken", "bull", "isordered", "list", "itemRegex", "endsWithBlankLine", "endEarly", "itemContents", "line", "expandTabs", "nextLine", "blankLine", "indent", "nextBulletRegex", "hrRegex", "fencesBeginRegex", "headingBeginRegex", "htmlBeginRegex", "blockquoteBeginRegex", "rawLine", "nextLineWithoutTabs", "lastItem", "item", "itemToken", "taskRaw", "checkboxToken", "spacers", "t", "hasMultipleLineBreaks", "tag", "headers", "splitCells", "aligns", "rows", "align", "row", "cell", "trimmedUrl", "rtrimSlash", "lastParenIndex", "findClosingBracket", "linkLen", "links", "linkString", "maskedSrc", "prevChar", "match", "lLength", "rDelim", "rLength", "delimTotal", "midDelimTotal", "endReg", "lastCharLength", "hasNonSpaceChars", "hasSpaceCharsOnBothEnds", "prevCapZero", "escaped", "_Lexer", "__Lexer", "options", "_defaults", "_Tokenizer", "rules", "other", "block", "inline", "src", "i", "next", "tokens", "lastParagraphClipped", "srcLength", "token", "extTokenizer", "lastToken", "cutSrc", "startIndex", "tempSrc", "tempStart", "getStartIndex", "maskedSrc", "match", "links", "offset", "keepPrevChar", "prevChar", "byte", "errMsg", "_Renderer", "options", "_defaults", "token", "text", "lang", "escaped", "langString", "other", "code", "escapeHtmlEntities", "tokens", "depth", "ordered", "start", "body", "j", "item", "type", "startAttr", "checked", "header", "cell", "row", "k", "content", "href", "title", "cleanHref", "cleanUrl", "out", "_TextRenderer", "text", "raw", "_Parser", "__Parser", "options", "_defaults", "_Renderer", "_TextRenderer", "tokens", "out", "i", "anyToken", "genericToken", "ret", "token", "errMsg", "renderer", "_Hooks", "options", "_defaults", "markdown", "html", "tokens", "src", "block", "_Lexer", "_Parser", "Marked", "_getDefaults", "_Parser", "_Renderer", "_TextRenderer", "_Lexer", "_Tokenizer", "_Hooks", "args", "tokens", "callback", "values", "token", "tableToken", "cell", "row", "listToken", "genericToken", "childTokens", "extensions", "pack", "opts", "ext", "prevRenderer", "ret", "extLevel", "renderer", "prop", "rendererProp", "rendererFunc", "tokenizer", "tokenizerProp", "tokenizerFunc", "prevTokenizer", "hooks", "hooksProp", "hooksFunc", "prevHook", "arg", "walkTokens", "packWalktokens", "opt", "src", "options", "blockType", "origOpt", "throwError", "processedSrc", "processedTokens", "html", "e", "silent", "async", "msg", "escapeHtmlEntities", "markedInstance", "Marked", "marked", "src", "opt", "options", "changeDefaults", "_getDefaults", "_defaults", "args", "tokens", "callback", "_Parser", "_Renderer", "_TextRenderer", "_Lexer", "_Tokenizer", "_Hooks", "setOptions", "use", "walkTokens", "parseInline", "parse", "parser", "lexer"] +} diff --git a/frontend/node_modules/marked/lib/marked.umd.js b/frontend/node_modules/marked/lib/marked.umd.js new file mode 100644 index 0000000..c83bf6a --- /dev/null +++ b/frontend/node_modules/marked/lib/marked.umd.js @@ -0,0 +1,79 @@ +/** + * marked v18.0.5 - a markdown parser + * Copyright (c) 2018-2026, MarkedJS. (MIT License) + * Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License) + * https://github.com/markedjs/marked + */ + +/** + * DO NOT EDIT THIS FILE + * The code in this file is generated from files in ./src/ + */ +(function(g,f){if(typeof exports=="object"&&typeof module<"u"){module.exports=f()}else if("function"==typeof define && define.amd){define("marked",f)}else {g["marked"]=f()}}(typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : this,function(){var exports={};var __exports=exports;var module={exports}; +"use strict";var N=Object.defineProperty;var Oe=Object.getOwnPropertyDescriptor;var we=Object.getOwnPropertyNames;var ye=Object.prototype.hasOwnProperty;var Pe=(l,e)=>{for(var t in e)N(l,t,{get:e[t],enumerable:!0})},Se=(l,e,t,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of we(e))!ye.call(l,s)&&s!==t&&N(l,s,{get:()=>e[s],enumerable:!(n=Oe(e,s))||n.enumerable});return l};var $e=l=>Se(N({},"__esModule",{value:!0}),l);var Rt={};Pe(Rt,{Hooks:()=>P,Lexer:()=>x,Marked:()=>C,Parser:()=>b,Renderer:()=>y,TextRenderer:()=>S,Tokenizer:()=>w,defaults:()=>T,getDefaults:()=>_,lexer:()=>bt,marked:()=>g,options:()=>ht,parse:()=>mt,parseInline:()=>ft,parser:()=>xt,setOptions:()=>kt,use:()=>dt,walkTokens:()=>gt});module.exports=$e(Rt);function _(){return{async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null}}var T=_();function Q(l){T=l}var z={exec:()=>null};function E(l){let e=[];return t=>{let n=Math.max(0,Math.min(3,t-1)),s=e[n];return s||(s=l(n),e[n]=s),s}}function d(l,e=""){let t=typeof l=="string"?l:l.source,n={replace:(s,r)=>{let i=typeof r=="string"?r:r.source;return i=i.replace(m.caret,"$1"),t=t.replace(s,i),n},getRegex:()=>new RegExp(t,e)};return n}var Le=((l="")=>{try{return!!new RegExp("(?<=1)(?/,blockquoteSetextReplace:/\n {0,3}((?:=+|-+) *)(?=\n|$)/g,blockquoteSetextReplace2:/^ {0,3}>[ \t]?/gm,listReplaceNesting:/^ {1,4}(?=( {4})*[^ ])/g,listIsTask:/^\[[ xX]\] +\S/,listReplaceTask:/^\[[ xX]\] +/,listTaskCheckbox:/\[[ 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,caret:/(^|[^\[])\^/g,percentDecode:/%25/g,findPipe:/\|/g,splitPipe:/ \|/,slashPipe:/\\\|/g,carriageReturn:/\r\n|\r/g,spaceLine:/^ +$/gm,notSpaceStart:/^\S*/,endingNewline:/\n$/,listItemRegex:l=>new RegExp(`^( {0,3}${l})((?:[ ][^\\n]*)?(?:\\n|$))`),nextBulletRegex:E(l=>new RegExp(`^ {0,${l}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`)),hrRegex:E(l=>new RegExp(`^ {0,${l}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`)),fencesBeginRegex:E(l=>new RegExp(`^ {0,${l}}(?:\`\`\`|~~~)`)),headingBeginRegex:E(l=>new RegExp(`^ {0,${l}}#`)),htmlBeginRegex:E(l=>new RegExp(`^ {0,${l}}<(?:[a-z].*>|!--)`,"i")),blockquoteBeginRegex:E(l=>new RegExp(`^ {0,${l}}>`))},_e=/^(?:[ \t]*(?:\n|$))+/,ze=/^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/,Me=/^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,D=/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,Ee=/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,F=/ {0,3}(?:[*+-]|\d{1,9}[.)])/,ae=/^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/,le=d(ae).replace(/bull/g,F).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(),Ie=d(ae).replace(/bull/g,F).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(),U=/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,Ae=/^[^\n]+/,K=/(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/,Ce=d(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label",K).replace("title",/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(),Be=d(/^(bull)([ \t][^\n]*?)?(?:\n|$)/).replace(/bull/g,F).getRegex(),H="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",W=/|$))/,De=d("^ {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",W).replace("tag",H).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),ue=d(U).replace("hr",D).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[.)])[ \\t]+[^ \\t\\n]").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",H).getRegex(),qe=d(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph",ue).getRegex(),X={blockquote:qe,code:ze,def:Ce,fences:Me,heading:Ee,hr:D,html:De,lheading:le,list:Be,newline:_e,paragraph:ue,table:z,text:Ae},ie=d("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr",D).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[.)])[ \\t]").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",H).getRegex(),ve={...X,lheading:Ie,table:ie,paragraph:d(U).replace("hr",D).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("table",ie).replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]").replace("html",")|<(?:script|pre|style|textarea|!--)").replace("tag",H).getRegex()},He={...X,html:d(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment",W).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:z,lheading:/^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,paragraph:d(U).replace("hr",D).replace("heading",` *#{1,6} *[^ +]`).replace("lheading",le).replace("|table","").replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").replace("|tag","").getRegex()},Ze=/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,Ge=/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,pe=/^( {2,}|\\)\n(?!\s*$)/,Ne=/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\`+)[^`]+\k(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-",Le?"(?`+)[^`]+\k(?!`)/).replace("html",/<(?! )[^<>]*?>/).getRegex(),he=/^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/,Ke=d(he,"u").replace(/punct/g,I).getRegex(),We=d(he,"u").replace(/punct/g,ce).getRegex(),ke="^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)",Xe=d(ke,"gu").replace(/notPunctSpace/g,J).replace(/punctSpace/g,Z).replace(/punct/g,I).getRegex(),Je=d(ke,"gu").replace(/notPunctSpace/g,Fe).replace(/punctSpace/g,je).replace(/punct/g,ce).getRegex(),Ve=d("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)","gu").replace(/notPunctSpace/g,J).replace(/punctSpace/g,Z).replace(/punct/g,I).getRegex(),Ye=d(/^~~?(?:((?!~)punct)|[^\s~])/,"u").replace(/punct/g,I).getRegex(),et="^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)",tt=d(et,"gu").replace(/notPunctSpace/g,J).replace(/punctSpace/g,Z).replace(/punct/g,I).getRegex(),nt=d(/\\(punct)/,"gu").replace(/punct/g,I).getRegex(),rt=d(/^<(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(),st=d(W).replace("(?:-->|$)","-->").getRegex(),it=d("^comment|^|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^|^").replace("comment",st).replace("attribute",/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(),v=/(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/,ot=d(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label",v).replace("href",/<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title",/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(),de=d(/^!?\[(label)\]\[(ref)\]/).replace("label",v).replace("ref",K).getRegex(),ge=d(/^!?\[(ref)\](?:\[\])?/).replace("ref",K).getRegex(),at=d("reflink|nolink(?!\\()","g").replace("reflink",de).replace("nolink",ge).getRegex(),oe=/[hH][tT][tT][pP][sS]?|[fF][tT][pP]/,V={_backpedal:z,anyPunctuation:nt,autolink:rt,blockSkip:Ue,br:pe,code:Ge,del:z,delLDelim:z,delRDelim:z,emStrongLDelim:Ke,emStrongRDelimAst:Xe,emStrongRDelimUnd:Ve,escape:Ze,link:ot,nolink:ge,punctuation:Qe,reflink:de,reflinkSearch:at,tag:it,text:Ne,url:z},lt={...V,link:d(/^!?\[(label)\]\((.*?)\)/).replace("label",v).getRegex(),reflink:d(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",v).getRegex()},j={...V,emStrongRDelimAst:Je,emStrongLDelim:We,delLDelim:Ye,delRDelim:tt,url:d(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol",oe).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\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/,text:d(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\":">",'"':""","'":"'"},fe=l=>pt[l];function O(l,e){if(e){if(m.escapeTest.test(l))return l.replace(m.escapeReplace,fe)}else if(m.escapeTestNoEncode.test(l))return l.replace(m.escapeReplaceNoEncode,fe);return l}function Y(l){try{l=encodeURI(l).replace(m.percentDecode,"%")}catch{return null}return l}function ee(l,e){let t=l.replace(m.findPipe,(r,i,o)=>{let u=!1,a=i;for(;--a>=0&&o[a]==="\\";)u=!u;return u?"|":" |"}),n=t.split(m.splitPipe),s=0;if(n[0].trim()||n.shift(),n.length>0&&!n.at(-1)?.trim()&&n.pop(),e)if(n.length>e)n.splice(e);else for(;n.length=0&&m.blankLine.test(e[t]);)t--;return e.length-t<=2?l:e.slice(0,t+1).join(` +`)}function me(l,e){if(l.indexOf(e[1])===-1)return-1;let t=0;for(let n=0;n0?-2:-1}function xe(l,e=0){let t=e,n="";for(let s of l)if(s===" "){let r=4-t%4;n+=" ".repeat(r),t+=r}else n+=s,t++;return n}function be(l,e,t,n,s){let r=e.href,i=e.title||null,o=l[1].replace(s.other.outputLinkReplace,"$1");n.state.inLink=!0;let u={type:l[0].charAt(0)==="!"?"image":"link",raw:t,href:r,title:i,text:o,tokens:n.inlineTokens(o)};return n.state.inLink=!1,u}function ct(l,e,t){let n=l.match(t.other.indentCodeCompensation);if(n===null)return e;let s=n[1];return e.split(` +`).map(r=>{let i=r.match(t.other.beginningSpace);if(i===null)return r;let[o]=i;return o.length>=s.length?r.slice(s.length):r}).join(` +`)}var w=class{options;rules;lexer;constructor(e){this.options=e||T}space(e){let t=this.rules.block.newline.exec(e);if(t&&t[0].length>0)return{type:"space",raw:t[0]}}code(e){let t=this.rules.block.code.exec(e);if(t){let n=this.options.pedantic?t[0]:te(t[0]),s=n.replace(this.rules.other.codeRemoveIndent,"");return{type:"code",raw:n,codeBlockStyle:"indented",text:s}}}fences(e){let t=this.rules.block.fences.exec(e);if(t){let n=t[0],s=ct(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:s}}}heading(e){let t=this.rules.block.heading.exec(e);if(t){let n=t[2].trim();if(this.rules.other.endingHash.test(n)){let s=L(n,"#");(this.options.pedantic||!s||this.rules.other.endingSpaceChar.test(s))&&(n=s.trim())}return{type:"heading",raw:L(t[0],` +`),depth:t[1].length,text:n,tokens:this.lexer.inline(n)}}}hr(e){let t=this.rules.block.hr.exec(e);if(t)return{type:"hr",raw:L(t[0],` +`)}}blockquote(e){let t=this.rules.block.blockquote.exec(e);if(t){let n=L(t[0],` +`).split(` +`),s="",r="",i=[];for(;n.length>0;){let o=!1,u=[],a;for(a=0;a1,r={type:"list",raw:"",ordered:s,start:s?+n.slice(0,-1):"",loose:!1,items:[]};n=s?`\\d{1,9}\\${n.slice(-1)}`:`\\${n}`,this.options.pedantic&&(n=s?n:"[*+-]");let i=this.rules.other.listItemRegex(n),o=!1;for(;e;){let a=!1,c="",p="";if(!(t=i.exec(e))||this.rules.block.hr.test(e))break;c=t[0],e=e.substring(c.length);let k=xe(t[2].split(` +`,1)[0],t[1].length),h=e.split(` +`,1)[0],R=!k.trim(),f=0;if(this.options.pedantic?(f=2,p=k.trimStart()):R?f=t[1].length+1:(f=k.search(this.rules.other.nonSpaceChar),f=f>4?1:f,p=k.slice(f),f+=t[1].length),R&&this.rules.other.blankLine.test(h)&&(c+=h+` +`,e=e.substring(h.length+1),a=!0),!a){let $=this.rules.other.nextBulletRegex(f),ne=this.rules.other.hrRegex(f),re=this.rules.other.fencesBeginRegex(f),se=this.rules.other.headingBeginRegex(f),Re=this.rules.other.htmlBeginRegex(f),Te=this.rules.other.blockquoteBeginRegex(f);for(;e;){let G=e.split(` +`,1)[0],B;if(h=G,this.options.pedantic?(h=h.replace(this.rules.other.listReplaceNesting," "),B=h):B=h.replace(this.rules.other.tabCharGlobal," "),re.test(h)||se.test(h)||Re.test(h)||Te.test(h)||$.test(h)||ne.test(h))break;if(B.search(this.rules.other.nonSpaceChar)>=f||!h.trim())p+=` +`+B.slice(f);else{if(R||k.replace(this.rules.other.tabCharGlobal," ").search(this.rules.other.nonSpaceChar)>=4||re.test(k)||se.test(k)||ne.test(k))break;p+=` +`+h}R=!h.trim(),c+=G+` +`,e=e.substring(G.length+1),k=B.slice(f)}}r.loose||(o?r.loose=!0:this.rules.other.doubleBlankLine.test(c)&&(o=!0)),r.items.push({type:"list_item",raw:c,task:!!this.options.gfm&&this.rules.other.listIsTask.test(p),loose:!1,text:p,tokens:[]}),r.raw+=c}let u=r.items.at(-1);if(u)u.raw=u.raw.trimEnd(),u.text=u.text.trimEnd();else return;r.raw=r.raw.trimEnd();for(let a of r.items){this.lexer.state.top=!1,a.tokens=this.lexer.blockTokens(a.text,[]);let c=a.tokens[0];if(a.task&&(c?.type==="text"||c?.type==="paragraph")){a.text=a.text.replace(this.rules.other.listReplaceTask,""),c.raw=c.raw.replace(this.rules.other.listReplaceTask,""),c.text=c.text.replace(this.rules.other.listReplaceTask,"");for(let k=this.lexer.inlineQueue.length-1;k>=0;k--)if(this.rules.other.listIsTask.test(this.lexer.inlineQueue[k].src)){this.lexer.inlineQueue[k].src=this.lexer.inlineQueue[k].src.replace(this.rules.other.listReplaceTask,"");break}let p=this.rules.other.listTaskCheckbox.exec(a.raw);if(p){let k={type:"checkbox",raw:p[0]+" ",checked:p[0]!=="[ ]"};a.checked=k.checked,r.loose?a.tokens[0]&&["paragraph","text"].includes(a.tokens[0].type)&&"tokens"in a.tokens[0]&&a.tokens[0].tokens?(a.tokens[0].raw=k.raw+a.tokens[0].raw,a.tokens[0].text=k.raw+a.tokens[0].text,a.tokens[0].tokens.unshift(k)):a.tokens.unshift({type:"paragraph",raw:k.raw,text:k.raw,tokens:[k]}):a.tokens.unshift(k)}}else a.task&&(a.task=!1);if(!r.loose){let p=a.tokens.filter(h=>h.type==="space"),k=p.length>0&&p.some(h=>this.rules.other.anyLine.test(h.raw));r.loose=k}}if(r.loose)for(let a of r.items){a.loose=!0;for(let c of a.tokens)c.type==="text"&&(c.type="paragraph")}return r}}html(e){let t=this.rules.block.html.exec(e);if(t){let n=te(t[0]);return{type:"html",block:!0,raw:n,pre:t[1]==="pre"||t[1]==="script"||t[1]==="style",text:n}}}def(e){let t=this.rules.block.def.exec(e);if(t){let n=t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal," "),s=t[2]?t[2].replace(this.rules.other.hrefBrackets,"$1").replace(this.rules.inline.anyPunctuation,"$1"):"",r=t[3]?t[3].substring(1,t[3].length-1).replace(this.rules.inline.anyPunctuation,"$1"):t[3];return{type:"def",tag:n,raw:L(t[0],` +`),href:s,title:r}}}table(e){let t=this.rules.block.table.exec(e);if(!t||!this.rules.other.tableDelimiter.test(t[2]))return;let n=ee(t[1]),s=t[2].replace(this.rules.other.tableAlignChars,"").split("|"),r=t[3]?.trim()?t[3].replace(this.rules.other.tableRowBlankLine,"").split(` +`):[],i={type:"table",raw:L(t[0],` +`),header:[],align:[],rows:[]};if(n.length===s.length){for(let o of s)this.rules.other.tableAlignRight.test(o)?i.align.push("right"):this.rules.other.tableAlignCenter.test(o)?i.align.push("center"):this.rules.other.tableAlignLeft.test(o)?i.align.push("left"):i.align.push(null);for(let o=0;o({text:u,tokens:this.lexer.inline(u),header:!1,align:i.align[a]})));return i}}lheading(e){let t=this.rules.block.lheading.exec(e);if(t){let n=t[1].trim();return{type:"heading",raw:L(t[0],` +`),depth:t[2].charAt(0)==="="?1:2,text:n,tokens:this.lexer.inline(n)}}}paragraph(e){let t=this.rules.block.paragraph.exec(e);if(t){let 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){let 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){let t=this.rules.inline.escape.exec(e);if(t)return{type:"escape",raw:t[0],text:t[1]}}tag(e){let 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){let t=this.rules.inline.link.exec(e);if(t){let n=t[2].trim();if(!this.options.pedantic&&this.rules.other.startAngleBracket.test(n)){if(!this.rules.other.endAngleBracket.test(n))return;let i=L(n.slice(0,-1),"\\");if((n.length-i.length)%2===0)return}else{let i=me(t[2],"()");if(i===-2)return;if(i>-1){let u=(t[0].indexOf("!")===0?5:4)+t[1].length+i;t[2]=t[2].substring(0,i),t[0]=t[0].substring(0,u).trim(),t[3]=""}}let s=t[2],r="";if(this.options.pedantic){let i=this.rules.other.pedanticHrefTitle.exec(s);i&&(s=i[1],r=i[3])}else r=t[3]?t[3].slice(1,-1):"";return s=s.trim(),this.rules.other.startAngleBracket.test(s)&&(this.options.pedantic&&!this.rules.other.endAngleBracket.test(n)?s=s.slice(1):s=s.slice(1,-1)),be(t,{href:s&&s.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))){let s=(n[2]||n[1]).replace(this.rules.other.multipleSpaceGlobal," "),r=t[s.toLowerCase()];if(!r){let i=n[0].charAt(0);return{type:"text",raw:i,text:i}}return be(n,r,n[0],this.lexer,this.rules)}}emStrong(e,t,n=""){let s=this.rules.inline.emStrongLDelim.exec(e);if(!s||!s[1]&&!s[2]&&!s[3]&&!s[4]||s[4]&&n.match(this.rules.other.unicodeAlphaNumeric))return;if(!(s[1]||s[3]||"")||!n||this.rules.inline.punctuation.exec(n)){let i=[...s[0]].length-1,o,u,a=i,c=0,p=s[0][0]==="*"?this.rules.inline.emStrongRDelimAst:this.rules.inline.emStrongRDelimUnd;for(p.lastIndex=0,t=t.slice(-1*e.length+i);(s=p.exec(t))!==null;){if(o=s[1]||s[2]||s[3]||s[4]||s[5]||s[6],!o)continue;if(u=[...o].length,s[3]||s[4]){a+=u;continue}else if((s[5]||s[6])&&i%3&&!((i+u)%3)){c+=u;continue}if(a-=u,a>0)continue;u=Math.min(u,u+a+c);let k=[...s[0]][0].length,h=e.slice(0,i+s.index+k+u);if(Math.min(i,u)%2){let f=h.slice(1,-1);return{type:"em",raw:h,text:f,tokens:this.lexer.inlineTokens(f)}}let R=h.slice(2,-2);return{type:"strong",raw:h,text:R,tokens:this.lexer.inlineTokens(R)}}}}codespan(e){let t=this.rules.inline.code.exec(e);if(t){let n=t[2].replace(this.rules.other.newLineCharGlobal," "),s=this.rules.other.nonSpaceChar.test(n),r=this.rules.other.startingSpaceChar.test(n)&&this.rules.other.endingSpaceChar.test(n);return s&&r&&(n=n.substring(1,n.length-1)),{type:"codespan",raw:t[0],text:n}}}br(e){let t=this.rules.inline.br.exec(e);if(t)return{type:"br",raw:t[0]}}del(e,t,n=""){let s=this.rules.inline.delLDelim.exec(e);if(!s)return;if(!(s[1]||"")||!n||this.rules.inline.punctuation.exec(n)){let i=[...s[0]].length-1,o,u,a=i,c=this.rules.inline.delRDelim;for(c.lastIndex=0,t=t.slice(-1*e.length+i);(s=c.exec(t))!==null;){if(o=s[1]||s[2]||s[3]||s[4]||s[5]||s[6],!o||(u=[...o].length,u!==i))continue;if(s[3]||s[4]){a+=u;continue}if(a-=u,a>0)continue;u=Math.min(u,u+a);let p=[...s[0]][0].length,k=e.slice(0,i+s.index+p+u),h=k.slice(i,-i);return{type:"del",raw:k,text:h,tokens:this.lexer.inlineTokens(h)}}}}autolink(e){let t=this.rules.inline.autolink.exec(e);if(t){let n,s;return t[2]==="@"?(n=t[1],s="mailto:"+n):(n=t[1],s=n),{type:"link",raw:t[0],text:n,href:s,tokens:[{type:"text",raw:n,text:n}]}}}url(e){let t;if(t=this.rules.inline.url.exec(e)){let n,s;if(t[2]==="@")n=t[0],s="mailto:"+n;else{let r;do r=t[0],t[0]=this.rules.inline._backpedal.exec(t[0])?.[0]??"";while(r!==t[0]);n=t[0],t[1]==="www."?s="http://"+t[0]:s=t[0]}return{type:"link",raw:t[0],text:n,href:s,tokens:[{type:"text",raw:n,text:n}]}}}inlineText(e){let t=this.rules.inline.text.exec(e);if(t){let n=this.lexer.state.inRawBlock;return{type:"text",raw:t[0],text:t[0],escaped:n}}}};var x=class l{tokens;options;state;inlineQueue;tokenizer;constructor(e){this.tokens=[],this.tokens.links=Object.create(null),this.options=e||T,this.options.tokenizer=this.options.tokenizer||new w,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options,this.tokenizer.lexer=this,this.inlineQueue=[],this.state={inLink:!1,inRawBlock:!1,top:!0};let t={other:m,block:q.normal,inline:A.normal};this.options.pedantic?(t.block=q.pedantic,t.inline=A.pedantic):this.options.gfm&&(t.block=q.gfm,this.options.breaks?t.inline=A.breaks:t.inline=A.gfm),this.tokenizer.rules=t}static get rules(){return{block:q,inline:A}}static lex(e,t){return new l(t).lex(e)}static lexInline(e,t){return new l(t).inlineTokens(e)}lex(e){e=e.replace(m.carriageReturn,` +`),this.blockTokens(e,this.tokens);for(let t=0;t(r=o.call({lexer:this},e,t))?(e=e.substring(r.raw.length),t.push(r),!0):!1))continue;if(r=this.tokenizer.space(e)){e=e.substring(r.raw.length);let o=t.at(-1);r.raw.length===1&&o!==void 0?o.raw+=` +`:t.push(r);continue}if(r=this.tokenizer.code(e)){e=e.substring(r.raw.length);let o=t.at(-1);o?.type==="paragraph"||o?.type==="text"?(o.raw+=(o.raw.endsWith(` +`)?"":` +`)+r.raw,o.text+=` +`+r.text,this.inlineQueue.at(-1).src=o.text):t.push(r);continue}if(r=this.tokenizer.fences(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.heading(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.hr(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.blockquote(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.list(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.html(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.def(e)){e=e.substring(r.raw.length);let o=t.at(-1);o?.type==="paragraph"||o?.type==="text"?(o.raw+=(o.raw.endsWith(` +`)?"":` +`)+r.raw,o.text+=` +`+r.raw,this.inlineQueue.at(-1).src=o.text):this.tokens.links[r.tag]||(this.tokens.links[r.tag]={href:r.href,title:r.title},t.push(r));continue}if(r=this.tokenizer.table(e)){e=e.substring(r.raw.length),t.push(r);continue}if(r=this.tokenizer.lheading(e)){e=e.substring(r.raw.length),t.push(r);continue}let i=e;if(this.options.extensions?.startBlock){let o=1/0,u=e.slice(1),a;this.options.extensions.startBlock.forEach(c=>{a=c.call({lexer:this},u),typeof a=="number"&&a>=0&&(o=Math.min(o,a))}),o<1/0&&o>=0&&(i=e.substring(0,o+1))}if(this.state.top&&(r=this.tokenizer.paragraph(i))){let o=t.at(-1);n&&o?.type==="paragraph"?(o.raw+=(o.raw.endsWith(` +`)?"":` +`)+r.raw,o.text+=` +`+r.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=o.text):t.push(r),n=i.length!==e.length,e=e.substring(r.raw.length);continue}if(r=this.tokenizer.text(e)){e=e.substring(r.raw.length);let o=t.at(-1);o?.type==="text"?(o.raw+=(o.raw.endsWith(` +`)?"":` +`)+r.raw,o.text+=` +`+r.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=o.text):t.push(r);continue}if(e){this.infiniteLoopError(e.charCodeAt(0));break}}return this.state.top=!0,t}inline(e,t=[]){return this.inlineQueue.push({src:e,tokens:t}),t}inlineTokens(e,t=[]){this.tokenizer.lexer=this;let n=e,s=null;if(this.tokens.links){let a=Object.keys(this.tokens.links);if(a.length>0)for(;(s=this.tokenizer.rules.inline.reflinkSearch.exec(n))!==null;)a.includes(s[0].slice(s[0].lastIndexOf("[")+1,-1))&&(n=n.slice(0,s.index)+"["+"a".repeat(s[0].length-2)+"]"+n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;(s=this.tokenizer.rules.inline.anyPunctuation.exec(n))!==null;)n=n.slice(0,s.index)+"++"+n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);let r;for(;(s=this.tokenizer.rules.inline.blockSkip.exec(n))!==null;)r=s[2]?s[2].length:0,n=n.slice(0,s.index+r)+"["+"a".repeat(s[0].length-r-2)+"]"+n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);n=this.options.hooks?.emStrongMask?.call({lexer:this},n)??n;let i=!1,o="",u=1/0;for(;e;){if(e.length(a=p.call({lexer:this},e,t))?(e=e.substring(a.raw.length),t.push(a),!0):!1))continue;if(a=this.tokenizer.escape(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.tag(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.link(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.reflink(e,this.tokens.links)){e=e.substring(a.raw.length);let p=t.at(-1);a.type==="text"&&p?.type==="text"?(p.raw+=a.raw,p.text+=a.text):t.push(a);continue}if(a=this.tokenizer.emStrong(e,n,o)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.codespan(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.br(e)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.del(e,n,o)){e=e.substring(a.raw.length),t.push(a);continue}if(a=this.tokenizer.autolink(e)){e=e.substring(a.raw.length),t.push(a);continue}if(!this.state.inLink&&(a=this.tokenizer.url(e))){e=e.substring(a.raw.length),t.push(a);continue}let c=e;if(this.options.extensions?.startInline){let p=1/0,k=e.slice(1),h;this.options.extensions.startInline.forEach(R=>{h=R.call({lexer:this},k),typeof h=="number"&&h>=0&&(p=Math.min(p,h))}),p<1/0&&p>=0&&(c=e.substring(0,p+1))}if(a=this.tokenizer.inlineText(c)){e=e.substring(a.raw.length),a.raw.slice(-1)!=="_"&&(o=a.raw.slice(-1)),i=!0;let p=t.at(-1);p?.type==="text"?(p.raw+=a.raw,p.text+=a.text):t.push(a);continue}if(e){this.infiniteLoopError(e.charCodeAt(0));break}}return t}infiniteLoopError(e){let t="Infinite loop on byte: "+e;if(this.options.silent)console.error(t);else throw new Error(t)}};var y=class{options;parser;constructor(e){this.options=e||T}space(e){return""}code({text:e,lang:t,escaped:n}){let s=(t||"").match(m.notSpaceStart)?.[0],r=e.replace(m.endingNewline,"")+` +`;return s?'
    '+(n?r:O(r,!0))+`
    +`:"
    "+(n?r:O(r,!0))+`
    +`}blockquote({tokens:e}){return`
    +${this.parser.parse(e)}
    +`}html({text:e}){return e}def(e){return""}heading({tokens:e,depth:t}){return`${this.parser.parseInline(e)} +`}hr(e){return`
    +`}list(e){let t=e.ordered,n=e.start,s="";for(let o=0;o +`+s+" +`}listitem(e){return`
  • ${this.parser.parse(e.tokens)}
    • +`}checkbox({checked:e}){return" '}paragraph({tokens:e}){return`

    ${this.parser.parseInline(e)}

    +`}table(e){let t="",n="";for(let r=0;r${s}`),` + +`+t+` +`+s+`
    +`}tablerow({text:e}){return` +${e} +`}tablecell(e){let 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`${O(e,!0)}`}br(e){return"
    "}del({tokens:e}){return`${this.parser.parseInline(e)}`}link({href:e,title:t,tokens:n}){let s=this.parser.parseInline(n),r=Y(e);if(r===null)return s;e=r;let i='    ",i}image({href:e,title:t,text:n,tokens:s}){s&&(n=this.parser.parseInline(s,this.parser.textRenderer));let r=Y(e);if(r===null)return O(n);e=r;let i=`${O(n)}{let o=r[i].flat(1/0);n=n.concat(this.walkTokens(o,t))}):r.tokens&&(n=n.concat(this.walkTokens(r.tokens,t)))}}return n}use(...e){let t=this.defaults.extensions||{renderers:{},childTokens:{}};return e.forEach(n=>{let s={...n};if(s.async=this.defaults.async||s.async||!1,n.extensions&&(n.extensions.forEach(r=>{if(!r.name)throw new Error("extension name required");if("renderer"in r){let i=t.renderers[r.name];i?t.renderers[r.name]=function(...o){let u=r.renderer.apply(this,o);return u===!1&&(u=i.apply(this,o)),u}: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'");let 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)}),s.extensions=t),n.renderer){let r=this.defaults.renderer||new y(this.defaults);for(let i in n.renderer){if(!(i in r))throw new Error(`renderer '${i}' does not exist`);if(["options","parser"].includes(i))continue;let o=i,u=n.renderer[o],a=r[o];r[o]=(...c)=>{let p=u.apply(r,c);return p===!1&&(p=a.apply(r,c)),p||""}}s.renderer=r}if(n.tokenizer){let r=this.defaults.tokenizer||new w(this.defaults);for(let i in n.tokenizer){if(!(i in r))throw new Error(`tokenizer '${i}' does not exist`);if(["options","rules","lexer"].includes(i))continue;let o=i,u=n.tokenizer[o],a=r[o];r[o]=(...c)=>{let p=u.apply(r,c);return p===!1&&(p=a.apply(r,c)),p}}s.tokenizer=r}if(n.hooks){let r=this.defaults.hooks||new P;for(let i in n.hooks){if(!(i in r))throw new Error(`hook '${i}' does not exist`);if(["options","block"].includes(i))continue;let o=i,u=n.hooks[o],a=r[o];P.passThroughHooks.has(i)?r[o]=c=>{if(this.defaults.async&&P.passThroughHooksRespectAsync.has(i))return(async()=>{let k=await u.call(r,c);return a.call(r,k)})();let p=u.call(r,c);return a.call(r,p)}:r[o]=(...c)=>{if(this.defaults.async)return(async()=>{let k=await u.apply(r,c);return k===!1&&(k=await a.apply(r,c)),k})();let p=u.apply(r,c);return p===!1&&(p=a.apply(r,c)),p}}s.hooks=r}if(n.walkTokens){let r=this.defaults.walkTokens,i=n.walkTokens;s.walkTokens=function(o){let u=[];return u.push(i.call(this,o)),r&&(u=u.concat(r.call(this,o))),u}}this.defaults={...this.defaults,...s}}),this}setOptions(e){return this.defaults={...this.defaults,...e},this}lexer(e,t){return x.lex(e,t??this.defaults)}parser(e,t){return b.parse(e,t??this.defaults)}parseMarkdown(e){return(n,s)=>{let r={...s},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"));if(i.hooks&&(i.hooks.options=i,i.hooks.block=e),i.async)return(async()=>{let u=i.hooks?await i.hooks.preprocess(n):n,c=await(i.hooks?await i.hooks.provideLexer(e):e?x.lex:x.lexInline)(u,i),p=i.hooks?await i.hooks.processAllTokens(c):c;i.walkTokens&&await Promise.all(this.walkTokens(p,i.walkTokens));let h=await(i.hooks?await i.hooks.provideParser(e):e?b.parse:b.parseInline)(p,i);return i.hooks?await i.hooks.postprocess(h):h})().catch(o);try{i.hooks&&(n=i.hooks.preprocess(n));let a=(i.hooks?i.hooks.provideLexer(e):e?x.lex:x.lexInline)(n,i);i.hooks&&(a=i.hooks.processAllTokens(a)),i.walkTokens&&this.walkTokens(a,i.walkTokens);let p=(i.hooks?i.hooks.provideParser(e):e?b.parse:b.parseInline)(a,i);return i.hooks&&(p=i.hooks.postprocess(p)),p}catch(u){return o(u)}}}onError(e,t){return n=>{if(n.message+=` +Please report this to https://github.com/markedjs/marked.`,e){let s="

    An error occurred:

    "+O(n.message+"",!0)+"
    ";return t?Promise.resolve(s):s}if(t)return Promise.reject(n);throw n}}};var M=new C;function g(l,e){return M.parse(l,e)}g.options=g.setOptions=function(l){return M.setOptions(l),g.defaults=M.defaults,Q(g.defaults),g};g.getDefaults=_;g.defaults=T;g.use=function(...l){return M.use(...l),g.defaults=M.defaults,Q(g.defaults),g};g.walkTokens=function(l,e){return M.walkTokens(l,e)};g.parseInline=M.parseInline;g.Parser=b;g.parser=b.parse;g.Renderer=y;g.TextRenderer=S;g.Lexer=x;g.lexer=x.lex;g.Tokenizer=w;g.Hooks=P;g.parse=g;var ht=g.options,kt=g.setOptions,dt=g.use,gt=g.walkTokens,ft=g.parseInline,mt=g,xt=b.parse,bt=x.lex; + +if(__exports != exports)module.exports = exports;return module.exports})); +//# sourceMappingURL=marked.umd.js.map diff --git a/frontend/node_modules/marked/lib/marked.umd.js.map b/frontend/node_modules/marked/lib/marked.umd.js.map new file mode 100644 index 0000000..6d5c28c --- /dev/null +++ b/frontend/node_modules/marked/lib/marked.umd.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../src/marked.ts", "../src/defaults.ts", "../src/rules.ts", "../src/helpers.ts", "../src/Tokenizer.ts", "../src/Lexer.ts", "../src/Renderer.ts", "../src/TextRenderer.ts", "../src/Parser.ts", "../src/Hooks.ts", "../src/Instance.ts"], + "sourcesContent": ["import { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport { _Tokenizer } from './Tokenizer.ts';\nimport { _Renderer } from './Renderer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { _Hooks } from './Hooks.ts';\nimport { Marked } from './Instance.ts';\nimport {\n _getDefaults,\n changeDefaults,\n _defaults,\n} from './defaults.ts';\nimport type { MarkedExtension, MarkedOptions } from './MarkedOptions.ts';\nimport type { Token, TokensList } from './Tokens.ts';\nimport type { MaybePromise } from './Instance.ts';\n\nconst markedInstance = new Marked();\n\n/**\n * Compiles markdown to HTML asynchronously.\n *\n * @param src String of markdown source to be compiled\n * @param options Hash of options, having async: true\n * @return Promise of string of compiled HTML\n */\nexport function marked(src: string, options: MarkedOptions & { async: true }): Promise;\n\n/**\n * Compiles markdown to HTML.\n *\n * @param src String of markdown source to be compiled\n * @param options Optional hash of options\n * @return String of compiled HTML. Will be a Promise of string if async is set to true by any extensions.\n */\nexport function marked(src: string, options: MarkedOptions & { async: false }): string;\nexport function marked(src: string, options: MarkedOptions & { async: true }): Promise;\nexport function marked(src: string, options?: MarkedOptions | null): string | Promise;\nexport function marked(src: string, opt?: MarkedOptions | null): string | Promise {\n return markedInstance.parse(src, opt);\n}\n\n/**\n * Sets the default options.\n *\n * @param options Hash of options\n */\nmarked.options =\n marked.setOptions = function(options: MarkedOptions) {\n markedInstance.setOptions(options);\n marked.defaults = markedInstance.defaults;\n changeDefaults(marked.defaults);\n return marked;\n };\n\n/**\n * Gets the original marked default options.\n */\nmarked.getDefaults = _getDefaults;\n\nmarked.defaults = _defaults;\n\n/**\n * Use Extension\n */\n\nmarked.use = function(...args: MarkedExtension[]) {\n markedInstance.use(...args);\n marked.defaults = markedInstance.defaults;\n changeDefaults(marked.defaults);\n return marked;\n};\n\n/**\n * Run callback for every token\n */\n\nmarked.walkTokens = function(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) {\n return markedInstance.walkTokens(tokens, callback);\n};\n\n/**\n * Compiles markdown to HTML without enclosing `p` tag.\n *\n * @param src String of markdown source to be compiled\n * @param options Hash of options\n * @return String of compiled HTML\n */\nmarked.parseInline = markedInstance.parseInline;\n\n/**\n * Expose\n */\nmarked.Parser = _Parser;\nmarked.parser = _Parser.parse;\nmarked.Renderer = _Renderer;\nmarked.TextRenderer = _TextRenderer;\nmarked.Lexer = _Lexer;\nmarked.lexer = _Lexer.lex;\nmarked.Tokenizer = _Tokenizer;\nmarked.Hooks = _Hooks;\nmarked.parse = marked;\n\nexport const options = marked.options;\nexport const setOptions = marked.setOptions;\nexport const use = marked.use;\nexport const walkTokens = marked.walkTokens;\nexport const parseInline = marked.parseInline;\nexport const parse = marked;\nexport const parser = _Parser.parse;\nexport const lexer = _Lexer.lex;\nexport { _defaults as defaults, _getDefaults as getDefaults } from './defaults.ts';\nexport { _Lexer as Lexer } from './Lexer.ts';\nexport { _Parser as Parser } from './Parser.ts';\nexport { _Tokenizer as Tokenizer } from './Tokenizer.ts';\nexport { _Renderer as Renderer } from './Renderer.ts';\nexport { _TextRenderer as TextRenderer } from './TextRenderer.ts';\nexport { _Hooks as Hooks } from './Hooks.ts';\nexport { Marked } from './Instance.ts';\nexport type * from './MarkedOptions.ts';\nexport type * from './Tokens.ts';\n", "import type { MarkedOptions } from './MarkedOptions.ts';\n\n/**\n * Gets the original marked default options.\n */\nexport function _getDefaults(): MarkedOptions {\n return {\n async: false,\n breaks: false,\n extensions: null,\n gfm: true,\n hooks: null,\n pedantic: false,\n renderer: null,\n silent: false,\n tokenizer: null,\n walkTokens: null,\n };\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport let _defaults: MarkedOptions = _getDefaults();\n\nexport function changeDefaults(newDefaults: MarkedOptions) {\n _defaults = newDefaults;\n}\n", "const noopTest = { exec: () => null } as unknown as RegExp;\n\nfunction cachedIndentRegex(createRegex: (indent: number) => RegExp) {\n const cache: RegExp[] = [];\n return (indent: number) => {\n const cacheIndex = Math.max(0, Math.min(3, indent - 1));\n let regex = cache[cacheIndex];\n if (!regex) {\n regex = createRegex(cacheIndex);\n cache[cacheIndex] = regex;\n }\n return regex;\n };\n}\n\nfunction edit(regex: string | RegExp, opt = '') {\n let source = typeof regex === 'string' ? regex : regex.source;\n const obj = {\n replace: (name: string | RegExp, val: string | RegExp) => {\n let valSource = typeof val === 'string' ? val : val.source;\n valSource = valSource.replace(other.caret, '$1');\n source = source.replace(name, valSource);\n return obj;\n },\n getRegex: () => {\n return new RegExp(source, opt);\n },\n };\n return obj;\n}\n\n// use a default variable to ensure the regex is evaluated on client an not removed by minifiers\nconst supportsLookbehind = ((a = '') => {\ntry {\n return !!new RegExp('(?<=1)(?/,\n blockquoteSetextReplace: /\\n {0,3}((?:=+|-+) *)(?=\\n|$)/g,\n blockquoteSetextReplace2: /^ {0,3}>[ \\t]?/gm,\n listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,\n listIsTask: /^\\[[ xX]\\] +\\S/,\n listReplaceTask: /^\\[[ xX]\\] +/,\n listTaskCheckbox: /\\[[ xX]\\]/,\n anyLine: /\\n.*\\n/,\n hrefBrackets: /^<(.*)>$/,\n tableDelimiter: /[:|]/,\n tableAlignChars: /^\\||\\| *$/g,\n tableRowBlankLine: /\\n[ \\t]*$/,\n tableAlignRight: /^ *-+: *$/,\n tableAlignCenter: /^ *:-+: *$/,\n tableAlignLeft: /^ *:-+ *$/,\n startATag: /^    /i,\n startPreScriptTag: /^<(pre|code|kbd|script)(\\s|>)/i,\n endPreScriptTag: /^<\\/(pre|code|kbd|script)(\\s|>)/i,\n startAngleBracket: /^$/,\n pedanticHrefTitle: /^([^'\"]*[^\\s])\\s+(['\"])(.*)\\2/,\n unicodeAlphaNumeric: /[\\p{L}\\p{N}]/u,\n escapeTest: /[&<>\"']/,\n escapeReplace: /[&<>\"']/g,\n escapeTestNoEncode: /[<>\"']|&(?!(#\\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\\w+);)/,\n escapeReplaceNoEncode: /[<>\"']|&(?!(#\\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\\w+);)/g,\n caret: /(^|[^\\[])\\^/g,\n percentDecode: /%25/g,\n findPipe: /\\|/g,\n splitPipe: / \\|/,\n slashPipe: /\\\\\\|/g,\n carriageReturn: /\\r\\n|\\r/g,\n spaceLine: /^ +$/gm,\n notSpaceStart: /^\\S*/,\n endingNewline: /\\n$/,\n listItemRegex: (bull: string) => new RegExp(`^( {0,3}${bull})((?:[\\t ][^\\\\n]*)?(?:\\\\n|$))`),\n nextBulletRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}(?:[*+-]|\\\\d{1,9}[.)])((?:[ \\t][^\\\\n]*)?(?:\\\\n|$))`)),\n hrRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}((?:- *){3,}|(?:_ *){3,}|(?:\\\\* *){3,})(?:\\\\n+|$)`)),\n fencesBeginRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}(?:\\`\\`\\`|~~~)`)),\n headingBeginRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}#`)),\n htmlBeginRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}<(?:[a-z].*>|!--)`, 'i')),\n blockquoteBeginRegex: cachedIndentRegex((indent: number) => new RegExp(`^ {0,${indent}}>`)),\n};\n\n/**\n * Block-Level Grammar\n */\n\nconst newline = /^(?:[ \\t]*(?:\\n|$))+/;\nconst blockCode = /^((?: {4}| {0,3}\\t)[^\\n]+(?:\\n(?:[ \\t]*(?:\\n|$))*)?)+/;\nconst fences = /^ {0,3}(`{3,}(?=[^`\\n]*(?:\\n|$))|~{3,})([^\\n]*)(?:\\n|$)(?:|([\\s\\S]*?)(?:\\n|$))(?: {0,3}\\1[~`]* *(?=\\n|$)|$)/;\nconst hr = /^ {0,3}((?:-[\\t ]*){3,}|(?:_[ \\t]*){3,}|(?:\\*[ \\t]*){3,})(?:\\n+|$)/;\nconst heading = /^ {0,3}(#{1,6})(?=\\s|$)(.*)(?:\\n+|$)/;\nconst bullet = / {0,3}(?:[*+-]|\\d{1,9}[.)])/;\nconst lheadingCore = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\\n(?!\\s*?\\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/;\nconst lheading = edit(lheadingCore)\n .replace(/bull/g, bullet) // lists can interrupt\n .replace(/blockCode/g, /(?: {4}| {0,3}\\t)/) // indented code blocks can interrupt\n .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt\n .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt\n .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt\n .replace(/html/g, / {0,3}<[^\\n>]+>\\n/) // block html can interrupt\n .replace(/\\|table/g, '') // table not in commonmark\n .getRegex();\nconst lheadingGfm = edit(lheadingCore)\n .replace(/bull/g, bullet) // lists can interrupt\n .replace(/blockCode/g, /(?: {4}| {0,3}\\t)/) // indented code blocks can interrupt\n .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt\n .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt\n .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt\n .replace(/html/g, / {0,3}<[^\\n>]+>\\n/) // block html can interrupt\n .replace(/table/g, / {0,3}\\|?(?:[:\\- ]*\\|)+[\\:\\- ]*\\n/) // table can interrupt\n .getRegex();\nconst _paragraph = /^([^\\n]+(?:\\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\\n)[^\\n]+)*)/;\nconst blockText = /^[^\\n]+/;\nconst _blockLabel = /(?!\\s*\\])(?:\\\\[\\s\\S]|[^\\[\\]\\\\])+/;\nconst def = edit(/^ {0,3}\\[(label)\\]: *(?:\\n[ \\t]*)?([^<\\s][^\\s]*|<.*?>)(?:(?: +(?:\\n[ \\t]*)?| *\\n[ \\t]*)(title))? *(?:\\n+|$)/)\n .replace('label', _blockLabel)\n .replace('title', /(?:\"(?:\\\\\"?|[^\"\\\\])*\"|'[^'\\n]*(?:\\n[^'\\n]+)*\\n?'|\\([^()]*\\))/)\n .getRegex();\n\nconst list = edit(/^(bull)([ \\t][^\\n]*?)?(?:\\n|$)/)\n .replace(/bull/g, bullet)\n .getRegex();\n\nconst _tag = 'address|article|aside|base|basefont|blockquote|body|caption'\n + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'\n + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'\n + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'\n + '|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title'\n + '|tr|track|ul';\nconst _comment = /|$))/;\nconst html = edit(\n '^ {0,3}(?:' // optional indentation\n+ '<(script|pre|style|textarea)[\\\\s>][\\\\s\\\\S]*?(?:[^\\\\n]*\\\\n+|$)' // (1)\n+ '|comment[^\\\\n]*(\\\\n+|$)' // (2)\n+ '|<\\\\?[\\\\s\\\\S]*?(?:\\\\?>\\\\n*|$)' // (3)\n+ '|\\\\n*|$)' // (4)\n+ '|\\\\n*|$)' // (5)\n+ '|)[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (6)\n+ '|<(?!script|pre|style|textarea)([a-z][\\\\w-]*)(?:attribute)*? */?>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (7) open tag\n+ '|(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (7) closing tag\n+ ')', 'i')\n .replace('comment', _comment)\n .replace('tag', _tag)\n .replace('attribute', / +[a-zA-Z:_][\\w.:-]*(?: *= *\"[^\"\\n]*\"| *= *'[^'\\n]*'| *= *[^\\s\"'=<>`]+)?/)\n .getRegex();\n\nconst paragraph = edit(_paragraph)\n .replace('hr', hr)\n .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs\n .replace('|table', '')\n .replace('blockquote', ' {0,3}>')\n .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n .replace('list', ' {0,3}(?:[*+-]|1[.)])[ \\\\t]+[^ \\\\t\\\\n]') // only non-empty lists starting from 1 can interrupt\n .replace('html', ')|<(?:script|pre|style|textarea|!--)')\n .replace('tag', _tag) // pars can be interrupted by type (6) html blocks\n .getRegex();\n\nconst blockquote = edit(/^( {0,3}> ?(paragraph|[^\\n]*)(?:\\n|$))+/)\n .replace('paragraph', paragraph)\n .getRegex();\n\n/**\n * Normal Block Grammar\n */\n\nconst blockNormal = {\n blockquote,\n code: blockCode,\n def,\n fences,\n heading,\n hr,\n html,\n lheading,\n list,\n newline,\n paragraph,\n table: noopTest,\n text: blockText,\n};\n\ntype BlockKeys = keyof typeof blockNormal;\n\n/**\n * GFM Block Grammar\n */\n\nconst gfmTable = edit(\n '^ *([^\\\\n ].*)\\\\n' // Header\n+ ' {0,3}((?:\\\\| *)?:?-+:? *(?:\\\\| *:?-+:? *)*(?:\\\\| *)?)' // Align\n+ '(?:\\\\n((?:(?! *\\\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\\\n|$))*)\\\\n*|$)') // Cells\n .replace('hr', hr)\n .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n .replace('blockquote', ' {0,3}>')\n .replace('code', '(?: {4}| {0,3}\\t)[^\\\\n]')\n .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n .replace('list', ' {0,3}(?:[*+-]|1[.)])[ \\\\t]') // any bullet ends the table rows\n .replace('html', ')|<(?:script|pre|style|textarea|!--)')\n .replace('tag', _tag) // tables can be interrupted by type (6) html blocks\n .getRegex();\n\nconst blockGfm: Record = {\n ...blockNormal,\n lheading: lheadingGfm,\n table: gfmTable,\n paragraph: edit(_paragraph)\n .replace('hr', hr)\n .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs\n .replace('table', gfmTable) // interrupt paragraphs with table\n .replace('blockquote', ' {0,3}>')\n .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n .replace('list', ' {0,3}(?:[*+-]|1[.)])[ \\\\t]+[^ \\\\t\\\\n]') // only non-empty lists starting from 1 can interrupt\n .replace('html', ')|<(?:script|pre|style|textarea|!--)')\n .replace('tag', _tag) // pars can be interrupted by type (6) html blocks\n .getRegex(),\n};\n\n/**\n * Pedantic grammar (original John Gruber's loose markdown specification)\n */\n\nconst blockPedantic: Record = {\n ...blockNormal,\n html: edit(\n '^ *(?:comment *(?:\\\\n|\\\\s*$)'\n + '|<(tag)[\\\\s\\\\S]+? *(?:\\\\n{2,}|\\\\s*$)' // closed tag\n + '|\\\\s]*)*?/?> *(?:\\\\n{2,}|\\\\s*$))')\n .replace('comment', _comment)\n .replace(/tag/g, '(?!(?:'\n + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub'\n + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)'\n + '\\\\b)\\\\w+(?!:|[^\\\\w\\\\s@]*@)\\\\b')\n .getRegex(),\n def: /^ *\\[([^\\]]+)\\]: *]+)>?(?: +([\"(][^\\n]+[\")]))? *(?:\\n+|$)/,\n heading: /^(#{1,6})(.*)(?:\\n+|$)/,\n fences: noopTest, // fences not supported\n lheading: /^(.+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/,\n paragraph: edit(_paragraph)\n .replace('hr', hr)\n .replace('heading', ' *#{1,6} *[^\\n]')\n .replace('lheading', lheading)\n .replace('|table', '')\n .replace('blockquote', ' {0,3}>')\n .replace('|fences', '')\n .replace('|list', '')\n .replace('|html', '')\n .replace('|tag', '')\n .getRegex(),\n};\n\n/**\n * Inline-Level Grammar\n */\n\nconst escape = /^\\\\([!\"#$%&'()*+,\\-./:;<=>?@\\[\\]\\\\^_`{|}~])/;\nconst inlineCode = /^(`+)([^`]|[^`][\\s\\S]*?[^`])\\1(?!`)/;\nconst br = /^( {2,}|\\\\)\\n(?!\\s*$)/;\nconst inlineText = /^(`+|[^`])(?:(?= {2,}\\n)|[\\s\\S]*?(?:(?=[\\\\\nconst blockSkip = edit(/link|precode-code|html/, 'g')\n .replace('link', /\\[(?:[^\\[\\]`]|(?`+)[^`]+\\k(?!`))*?\\]\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)]|\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)])*\\))*\\)/)\n .replace('precode-', supportsLookbehind ? '(?`+)[^`]+\\k(?!`)/)\n .replace('html', /<(?! )[^<>]*?>/)\n .getRegex();\n\nconst emStrongLDelimCore = /^(?:\\*+(?:((?!\\*)punct)|([^\\s*]))?)|^_+(?:((?!_)punct)|([^\\s_]))?/;\n\nconst emStrongLDelim = edit(emStrongLDelimCore, 'u')\n .replace(/punct/g, _punctuation)\n .getRegex();\n\nconst emStrongLDelimGfm = edit(emStrongLDelimCore, 'u')\n .replace(/punct/g, _punctuationGfmStrongEm)\n .getRegex();\n\nconst emStrongRDelimAstCore =\n '^[^_*]*?__[^_*]*?\\\\*[^_*]*?(?=__)' // Skip orphan inside strong\n+ '|[^*]+(?=[^*])' // Consume to delim\n+ '|(?!\\\\*)punct(\\\\*+)(?=[\\\\s]|$)' // (1) #*** can only be a Right Delimiter\n+ '|notPunctSpace(\\\\*+)(?!\\\\*)(?=punctSpace|$)' // (2) a***#, a*** can only be a Right Delimiter\n+ '|(?!\\\\*)punctSpace(\\\\*+)(?=notPunctSpace)' // (3) #***a, ***a can only be Left Delimiter\n+ '|[\\\\s](\\\\*+)(?!\\\\*)(?=punct)' // (4) ***# can only be Left Delimiter\n+ '|(?!\\\\*)punct(\\\\*+)(?!\\\\*)(?=punct)' // (5) #***# can be either Left or Right Delimiter\n+ '|notPunctSpace(\\\\*+)(?=notPunctSpace)'; // (6) a***a can be either Left or Right Delimiter\n\nconst emStrongRDelimAst = edit(emStrongRDelimAstCore, 'gu')\n .replace(/notPunctSpace/g, _notPunctuationOrSpace)\n .replace(/punctSpace/g, _punctuationOrSpace)\n .replace(/punct/g, _punctuation)\n .getRegex();\n\nconst emStrongRDelimAstGfm = edit(emStrongRDelimAstCore, 'gu')\n .replace(/notPunctSpace/g, _notPunctuationOrSpaceGfmStrongEm)\n .replace(/punctSpace/g, _punctuationOrSpaceGfmStrongEm)\n .replace(/punct/g, _punctuationGfmStrongEm)\n .getRegex();\n\n// (6) Not allowed for _\nconst emStrongRDelimUnd = edit(\n '^[^_*]*?\\\\*\\\\*[^_*]*?_[^_*]*?(?=\\\\*\\\\*)' // Skip orphan inside strong\n+ '|[^_]+(?=[^_])' // Consume to delim\n+ '|(?!_)punct(_+)(?=[\\\\s]|$)' // (1) #___ can only be a Right Delimiter\n+ '|notPunctSpace(_+)(?!_)(?=punctSpace|$)' // (2) a___#, a___ can only be a Right Delimiter\n+ '|(?!_)punctSpace(_+)(?=notPunctSpace)' // (3) #___a, ___a can only be Left Delimiter\n+ '|[\\\\s](_+)(?!_)(?=punct)' // (4) ___# can only be Left Delimiter\n+ '|(?!_)punct(_+)(?!_)(?=punct)', 'gu') // (5) #___# can be either Left or Right Delimiter\n .replace(/notPunctSpace/g, _notPunctuationOrSpace)\n .replace(/punctSpace/g, _punctuationOrSpace)\n .replace(/punct/g, _punctuation)\n .getRegex();\n\n// Tilde left delimiter for strikethrough (similar to emStrongLDelim for asterisk)\nconst delLDelim = edit(/^~~?(?:((?!~)punct)|[^\\s~])/, 'u')\n .replace(/punct/g, _punctuation)\n .getRegex();\n\n// Tilde delimiter patterns for strikethrough (similar to asterisk)\nconst delRDelimCore =\n '^[^~]+(?=[^~])' // Consume to delim\n+ '|(?!~)punct(~~?)(?=[\\\\s]|$)' // (1) #~~ can only be a Right Delimiter\n+ '|notPunctSpace(~~?)(?!~)(?=punctSpace|$)' // (2) a~~#, a~~ can only be a Right Delimiter\n+ '|(?!~)punctSpace(~~?)(?=notPunctSpace)' // (3) #~~a, ~~a can only be Left Delimiter\n+ '|[\\\\s](~~?)(?!~)(?=punct)' // (4) ~~# can only be Left Delimiter\n+ '|(?!~)punct(~~?)(?!~)(?=punct)' // (5) #~~# can be either Left or Right Delimiter\n+ '|notPunctSpace(~~?)(?=notPunctSpace)'; // (6) a~~a can be either Left or Right Delimiter\n\nconst delRDelim = edit(delRDelimCore, 'gu')\n .replace(/notPunctSpace/g, _notPunctuationOrSpace)\n .replace(/punctSpace/g, _punctuationOrSpace)\n .replace(/punct/g, _punctuation)\n .getRegex();\n\nconst anyPunctuation = edit(/\\\\(punct)/, 'gu')\n .replace(/punct/g, _punctuation)\n .getRegex();\n\nconst autolink = edit(/^<(scheme:[^\\s\\x00-\\x1f<>]*|email)>/)\n .replace('scheme', /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/)\n .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])?)+(?![-_])/)\n .getRegex();\n\nconst _inlineComment = edit(_comment).replace('(?:-->|$)', '-->').getRegex();\nconst tag = edit(\n '^comment'\n + '|^' // self-closing tag\n + '|^<[a-zA-Z][\\\\w-]*(?:attribute)*?\\\\s*/?>' // open tag\n + '|^<\\\\?[\\\\s\\\\S]*?\\\\?>' // processing instruction, e.g. \n + '|^' // declaration, e.g. \n + '|^') // CDATA section\n .replace('comment', _inlineComment)\n .replace('attribute', /\\s+[a-zA-Z:_][\\w.:-]*(?:\\s*=\\s*\"[^\"]*\"|\\s*=\\s*'[^']*'|\\s*=\\s*[^\\s\"'=<>`]+)?/)\n .getRegex();\n\nconst _inlineLabel = /(?:\\[(?:\\\\[\\s\\S]|[^\\[\\]\\\\])*\\]|\\\\[\\s\\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\\])|[^\\[\\]\\\\`])*?/;\n\nconst link = edit(/^!?\\[(label)\\]\\(\\s*(href)(?:(?:[ \\t]+(?:\\n[ \\t]*)?|\\n[ \\t]*)(title))?\\s*\\)/)\n .replace('label', _inlineLabel)\n .replace('href', /<(?:\\\\.|[^\\n<>\\\\])+>|[^ \\t\\n\\x00-\\x1f]*/)\n .replace('title', /\"(?:\\\\\"?|[^\"\\\\])*\"|'(?:\\\\'?|[^'\\\\])*'|\\((?:\\\\\\)?|[^)\\\\])*\\)/)\n .getRegex();\n\nconst reflink = edit(/^!?\\[(label)\\]\\[(ref)\\]/)\n .replace('label', _inlineLabel)\n .replace('ref', _blockLabel)\n .getRegex();\n\nconst nolink = edit(/^!?\\[(ref)\\](?:\\[\\])?/)\n .replace('ref', _blockLabel)\n .getRegex();\n\nconst reflinkSearch = edit('reflink|nolink(?!\\\\()', 'g')\n .replace('reflink', reflink)\n .replace('nolink', nolink)\n .getRegex();\n\nconst _caseInsensitiveProtocol = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/;\n\n/**\n * Normal Inline Grammar\n */\n\nconst inlineNormal = {\n _backpedal: noopTest, // only used for GFM url\n anyPunctuation,\n autolink,\n blockSkip,\n br,\n code: inlineCode,\n del: noopTest,\n delLDelim: noopTest,\n delRDelim: noopTest,\n emStrongLDelim,\n emStrongRDelimAst,\n emStrongRDelimUnd,\n escape,\n link,\n nolink,\n punctuation,\n reflink,\n reflinkSearch,\n tag,\n text: inlineText,\n url: noopTest,\n};\n\ntype InlineKeys = keyof typeof inlineNormal;\n\n/**\n * Pedantic Inline Grammar\n */\n\nconst inlinePedantic: Record = {\n ...inlineNormal,\n link: edit(/^!?\\[(label)\\]\\((.*?)\\)/)\n .replace('label', _inlineLabel)\n .getRegex(),\n reflink: edit(/^!?\\[(label)\\]\\s*\\[([^\\]]*)\\]/)\n .replace('label', _inlineLabel)\n .getRegex(),\n};\n\n/**\n * GFM Inline Grammar\n */\n\nconst inlineGfm: Record = {\n ...inlineNormal,\n emStrongRDelimAst: emStrongRDelimAstGfm,\n emStrongLDelim: emStrongLDelimGfm,\n delLDelim,\n delRDelim,\n url: edit(/^((?:protocol):\\/\\/|www\\.)(?:[a-zA-Z0-9\\-]+\\.?)+[^\\s<]*|^email/)\n .replace('protocol', _caseInsensitiveProtocol)\n .replace('email', /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/)\n .getRegex(),\n _backpedal: /(?:[^?!.,:;*_'\"~()&]+|\\([^)]*\\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'\"~)]+(?!$))+/,\n del: /^(~~?)(?=[^\\s~])((?:\\\\[\\s\\S]|[^\\\\])*?(?:\\\\[\\s\\S]|[^\\s~\\\\]))\\1(?=[^~]|$)/,\n text: edit(/^([`~]+|[^`~])(?:(?= {2,}\\n)|(?=[a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-]+@)|[\\s\\S]*?(?:(?=[\\\\ = {\n ...inlineGfm,\n br: edit(br).replace('{2,}', '*').getRegex(),\n text: edit(inlineGfm.text)\n .replace('\\\\b_', '\\\\b_| {2,}\\\\n')\n .replace(/\\{2,\\}/g, '*')\n .getRegex(),\n};\n\n/**\n * exports\n */\n\nexport const block = {\n normal: blockNormal,\n gfm: blockGfm,\n pedantic: blockPedantic,\n};\n\nexport const inline = {\n normal: inlineNormal,\n gfm: inlineGfm,\n breaks: inlineBreaks,\n pedantic: inlinePedantic,\n};\n\nexport interface Rules {\n other: typeof other\n block: Record\n inline: Record\n}\n", "import { other } from './rules.ts';\n\n/**\n * Helpers\n */\nconst escapeReplacements: { [index: string]: string } = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": ''',\n};\nconst getEscapeReplacement = (ch: string) => escapeReplacements[ch];\n\nexport function escapeHtmlEntities(html: string, encode?: boolean) {\n if (encode) {\n if (other.escapeTest.test(html)) {\n return html.replace(other.escapeReplace, getEscapeReplacement);\n }\n } else {\n if (other.escapeTestNoEncode.test(html)) {\n return html.replace(other.escapeReplaceNoEncode, getEscapeReplacement);\n }\n }\n\n return html;\n}\n\nexport function cleanUrl(href: string) {\n try {\n href = encodeURI(href).replace(other.percentDecode, '%');\n } catch {\n return null;\n }\n return href;\n}\n\nexport function splitCells(tableRow: string, count?: number) {\n // ensure that every cell-delimiting pipe has a space\n // before it to distinguish it from an escaped pipe\n const row = tableRow.replace(other.findPipe, (match, offset, str) => {\n let escaped = false;\n let curr = offset;\n while (--curr >= 0 && str[curr] === '\\\\') escaped = !escaped;\n if (escaped) {\n // odd number of slashes means | is escaped\n // so we leave it alone\n return '|';\n } else {\n // add space before unescaped |\n return ' |';\n }\n }),\n cells = row.split(other.splitPipe);\n let i = 0;\n\n // First/last cell in a row cannot be empty if it has no leading/trailing pipe\n if (!cells[0].trim()) {\n cells.shift();\n }\n if (cells.length > 0 && !cells.at(-1)?.trim()) {\n cells.pop();\n }\n\n if (count) {\n if (cells.length > count) {\n cells.splice(count);\n } else {\n while (cells.length < count) cells.push('');\n }\n }\n\n for (; i < cells.length; i++) {\n // leading or trailing whitespace is ignored per the gfm spec\n cells[i] = cells[i].trim().replace(other.slashPipe, '|');\n }\n return cells;\n}\n\n/**\n * Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').\n * /c*$/ is vulnerable to REDOS.\n *\n * @param str\n * @param c\n * @param invert Remove suffix of non-c chars instead. Default falsey.\n */\nexport function rtrim(str: string, c: string, invert?: boolean) {\n const l = str.length;\n if (l === 0) {\n return '';\n }\n\n // Length of suffix matching the invert condition.\n let suffLen = 0;\n\n // Step left until we fail to match the invert condition.\n while (suffLen < l) {\n const currChar = str.charAt(l - suffLen - 1);\n if (currChar === c && !invert) {\n suffLen++;\n } else if (currChar !== c && invert) {\n suffLen++;\n } else {\n break;\n }\n }\n\n return str.slice(0, l - suffLen);\n}\n\nexport function trimTrailingBlankLines(str: string) {\n const lines = str.split('\\n');\n let end = lines.length - 1;\n while (end >= 0 && other.blankLine.test(lines[end])) {\n end--;\n }\n if (lines.length - end <= 2) {\n // we want to keep single trailing blank lines\n return str;\n }\n\n return lines.slice(0, end + 1).join('\\n');\n}\n\nexport function findClosingBracket(str: string, b: string) {\n if (str.indexOf(b[1]) === -1) {\n return -1;\n }\n\n let level = 0;\n for (let i = 0; i < str.length; i++) {\n if (str[i] === '\\\\') {\n i++;\n } else if (str[i] === b[0]) {\n level++;\n } else if (str[i] === b[1]) {\n level--;\n if (level < 0) {\n return i;\n }\n }\n }\n if (level > 0) {\n return -2;\n }\n\n return -1;\n}\n\nexport function expandTabs(line: string, indent = 0) {\n let col = indent;\n let expanded = '';\n for (const char of line) {\n if (char === '\\t') {\n const added = 4 - (col % 4);\n expanded += ' '.repeat(added);\n col += added;\n } else {\n expanded += char;\n col++;\n }\n }\n\n return expanded;\n}\n", "import { _defaults } from './defaults.ts';\nimport {\n rtrim,\n splitCells,\n findClosingBracket,\n expandTabs,\n trimTrailingBlankLines,\n} from './helpers.ts';\nimport type { Rules } from './rules.ts';\nimport type { _Lexer } from './Lexer.ts';\nimport type { Links, Tokens, Token } from './Tokens.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\n\nfunction outputLink(cap: string[], link: Pick, raw: string, lexer: _Lexer, rules: Rules): Tokens.Link | Tokens.Image {\n const href = link.href;\n const title = link.title || null;\n const text = cap[1].replace(rules.other.outputLinkReplace, '$1');\n\n lexer.state.inLink = true;\n const token: Tokens.Link | Tokens.Image = {\n type: cap[0].charAt(0) === '!' ? 'image' : 'link',\n raw,\n href,\n title,\n text,\n tokens: lexer.inlineTokens(text),\n };\n lexer.state.inLink = false;\n return token;\n}\n\nfunction indentCodeCompensation(raw: string, text: string, rules: Rules) {\n const matchIndentToCode = raw.match(rules.other.indentCodeCompensation);\n\n if (matchIndentToCode === null) {\n return text;\n }\n\n const indentToCode = matchIndentToCode[1];\n\n return text\n .split('\\n')\n .map(node => {\n const matchIndentInNode = node.match(rules.other.beginningSpace);\n if (matchIndentInNode === null) {\n return node;\n }\n\n const [indentInNode] = matchIndentInNode;\n\n if (indentInNode.length >= indentToCode.length) {\n return node.slice(indentToCode.length);\n }\n\n return node;\n })\n .join('\\n');\n}\n\n/**\n * Tokenizer\n */\nexport class _Tokenizer {\n options: MarkedOptions;\n rules!: Rules; // set by the lexer\n lexer!: _Lexer; // set by the lexer\n\n constructor(options?: MarkedOptions) {\n this.options = options || _defaults;\n }\n\n space(src: string): Tokens.Space | undefined {\n const cap = this.rules.block.newline.exec(src);\n if (cap && cap[0].length > 0) {\n return {\n type: 'space',\n raw: cap[0],\n };\n }\n }\n\n code(src: string): Tokens.Code | undefined {\n const cap = this.rules.block.code.exec(src);\n if (cap) {\n const raw = this.options.pedantic\n ? cap[0]\n : trimTrailingBlankLines(cap[0]);\n const text = raw.replace(this.rules.other.codeRemoveIndent, '');\n return {\n type: 'code',\n raw,\n codeBlockStyle: 'indented',\n text,\n };\n }\n }\n\n fences(src: string): Tokens.Code | undefined {\n const cap = this.rules.block.fences.exec(src);\n if (cap) {\n const raw = cap[0];\n const text = indentCodeCompensation(raw, cap[3] || '', this.rules);\n\n return {\n type: 'code',\n raw,\n lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, '$1') : cap[2],\n text,\n };\n }\n }\n\n heading(src: string): Tokens.Heading | undefined {\n const cap = this.rules.block.heading.exec(src);\n if (cap) {\n let text = cap[2].trim();\n\n // remove trailing #s\n if (this.rules.other.endingHash.test(text)) {\n const trimmed = rtrim(text, '#');\n if (this.options.pedantic) {\n text = trimmed.trim();\n } else if (!trimmed || this.rules.other.endingSpaceChar.test(trimmed)) {\n // CommonMark requires space before trailing #s\n text = trimmed.trim();\n }\n }\n\n return {\n type: 'heading',\n raw: rtrim(cap[0], '\\n'),\n depth: cap[1].length,\n text,\n tokens: this.lexer.inline(text),\n };\n }\n }\n\n hr(src: string): Tokens.Hr | undefined {\n const cap = this.rules.block.hr.exec(src);\n if (cap) {\n return {\n type: 'hr',\n raw: rtrim(cap[0], '\\n'),\n };\n }\n }\n\n blockquote(src: string): Tokens.Blockquote | undefined {\n const cap = this.rules.block.blockquote.exec(src);\n if (cap) {\n let lines = rtrim(cap[0], '\\n').split('\\n');\n let raw = '';\n let text = '';\n const tokens: Token[] = [];\n\n while (lines.length > 0) {\n let inBlockquote = false;\n const currentLines = [];\n\n let i;\n for (i = 0; i < lines.length; i++) {\n // get lines up to a continuation\n if (this.rules.other.blockquoteStart.test(lines[i])) {\n currentLines.push(lines[i]);\n inBlockquote = true;\n } else if (!inBlockquote) {\n currentLines.push(lines[i]);\n } else {\n break;\n }\n }\n lines = lines.slice(i);\n\n const currentRaw = currentLines.join('\\n');\n const currentText = currentRaw\n // precede setext continuation with 4 spaces so it isn't a setext\n .replace(this.rules.other.blockquoteSetextReplace, '\\n $1')\n .replace(this.rules.other.blockquoteSetextReplace2, '');\n raw = raw ? `${raw}\\n${currentRaw}` : currentRaw;\n text = text ? `${text}\\n${currentText}` : currentText;\n\n // parse blockquote lines as top level tokens\n // merge paragraphs if this is a continuation\n const top = this.lexer.state.top;\n this.lexer.state.top = true;\n this.lexer.blockTokens(currentText, tokens, true);\n this.lexer.state.top = top;\n\n // if there is no continuation then we are done\n if (lines.length === 0) {\n break;\n }\n\n const lastToken = tokens.at(-1);\n\n if (lastToken?.type === 'code') {\n // blockquote continuation cannot be preceded by a code block\n break;\n } else if (lastToken?.type === 'blockquote') {\n // include continuation in nested blockquote\n const oldToken = lastToken as Tokens.Blockquote;\n const newText = oldToken.raw + '\\n' + lines.join('\\n');\n const newToken = this.blockquote(newText)!;\n tokens[tokens.length - 1] = newToken;\n\n raw = raw.substring(0, raw.length - oldToken.raw.length) + newToken.raw;\n text = text.substring(0, text.length - oldToken.text.length) + newToken.text;\n break;\n } else if (lastToken?.type === 'list') {\n // include continuation in nested list\n const oldToken = lastToken as Tokens.List;\n const newText = oldToken.raw + '\\n' + lines.join('\\n');\n const newToken = this.list(newText)!;\n tokens[tokens.length - 1] = newToken;\n\n raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;\n text = text.substring(0, text.length - oldToken.raw.length) + newToken.raw;\n lines = newText.substring(tokens.at(-1)!.raw.length).split('\\n');\n continue;\n }\n }\n\n return {\n type: 'blockquote',\n raw,\n tokens,\n text,\n };\n }\n }\n\n list(src: string): Tokens.List | undefined {\n let cap = this.rules.block.list.exec(src);\n if (cap) {\n let bull = cap[1].trim();\n const isordered = bull.length > 1;\n\n const list: Tokens.List = {\n type: 'list',\n raw: '',\n ordered: isordered,\n start: isordered ? +bull.slice(0, -1) : '',\n loose: false,\n items: [],\n };\n\n bull = isordered ? `\\\\d{1,9}\\\\${bull.slice(-1)}` : `\\\\${bull}`;\n\n if (this.options.pedantic) {\n bull = isordered ? bull : '[*+-]';\n }\n\n // Get next list item\n const itemRegex = this.rules.other.listItemRegex(bull);\n let endsWithBlankLine = false;\n // Check if current bullet point can start a new List Item\n while (src) {\n let endEarly = false;\n let raw = '';\n let itemContents = '';\n if (!(cap = itemRegex.exec(src))) {\n break;\n }\n\n if (this.rules.block.hr.test(src)) { // End list if bullet was actually HR (possibly move into itemRegex?)\n break;\n }\n\n raw = cap[0];\n src = src.substring(raw.length);\n\n let line = expandTabs(cap[2].split('\\n', 1)[0], cap[1].length);\n let nextLine = src.split('\\n', 1)[0];\n let blankLine = !line.trim();\n\n let indent = 0;\n if (this.options.pedantic) {\n indent = 2;\n itemContents = line.trimStart();\n } else if (blankLine) {\n indent = cap[1].length + 1;\n } else {\n indent = line.search(this.rules.other.nonSpaceChar); // Find first non-space char\n indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent\n itemContents = line.slice(indent);\n indent += cap[1].length;\n }\n\n if (blankLine && this.rules.other.blankLine.test(nextLine)) { // Items begin with at most one blank line\n raw += nextLine + '\\n';\n src = src.substring(nextLine.length + 1);\n endEarly = true;\n }\n\n if (!endEarly) {\n const nextBulletRegex = this.rules.other.nextBulletRegex(indent);\n const hrRegex = this.rules.other.hrRegex(indent);\n const fencesBeginRegex = this.rules.other.fencesBeginRegex(indent);\n const headingBeginRegex = this.rules.other.headingBeginRegex(indent);\n const htmlBeginRegex = this.rules.other.htmlBeginRegex(indent);\n const blockquoteBeginRegex = this.rules.other.blockquoteBeginRegex(indent);\n\n // Check if following lines should be included in List Item\n while (src) {\n const rawLine = src.split('\\n', 1)[0];\n let nextLineWithoutTabs;\n nextLine = rawLine;\n\n // Re-align to follow commonmark nesting rules\n if (this.options.pedantic) {\n nextLine = nextLine.replace(this.rules.other.listReplaceNesting, ' ');\n nextLineWithoutTabs = nextLine;\n } else {\n nextLineWithoutTabs = nextLine.replace(this.rules.other.tabCharGlobal, ' ');\n }\n\n // End list item if found code fences\n if (fencesBeginRegex.test(nextLine)) {\n break;\n }\n\n // End list item if found start of new heading\n if (headingBeginRegex.test(nextLine)) {\n break;\n }\n\n // End list item if found start of html block\n if (htmlBeginRegex.test(nextLine)) {\n break;\n }\n\n // End list item if found start of blockquote\n if (blockquoteBeginRegex.test(nextLine)) {\n break;\n }\n\n // End list item if found start of new bullet\n if (nextBulletRegex.test(nextLine)) {\n break;\n }\n\n // Horizontal rule found\n if (hrRegex.test(nextLine)) {\n break;\n }\n\n if (nextLineWithoutTabs.search(this.rules.other.nonSpaceChar) >= indent || !nextLine.trim()) { // Dedent if possible\n itemContents += '\\n' + nextLineWithoutTabs.slice(indent);\n } else {\n // not enough indentation\n if (blankLine) {\n break;\n }\n\n // paragraph continuation unless last line was a different block level element\n if (line.replace(this.rules.other.tabCharGlobal, ' ').search(this.rules.other.nonSpaceChar) >= 4) { // indented code block\n break;\n }\n if (fencesBeginRegex.test(line)) {\n break;\n }\n if (headingBeginRegex.test(line)) {\n break;\n }\n if (hrRegex.test(line)) {\n break;\n }\n\n itemContents += '\\n' + nextLine;\n }\n\n blankLine = !nextLine.trim();\n\n raw += rawLine + '\\n';\n src = src.substring(rawLine.length + 1);\n line = nextLineWithoutTabs.slice(indent);\n }\n }\n\n if (!list.loose) {\n // If the previous item ended with a blank line, the list is loose\n if (endsWithBlankLine) {\n list.loose = true;\n } else if (this.rules.other.doubleBlankLine.test(raw)) {\n endsWithBlankLine = true;\n }\n }\n\n list.items.push({\n type: 'list_item',\n raw,\n task: !!this.options.gfm && this.rules.other.listIsTask.test(itemContents),\n loose: false,\n text: itemContents,\n tokens: [],\n });\n\n list.raw += raw;\n }\n\n // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic\n const lastItem = list.items.at(-1);\n if (lastItem) {\n lastItem.raw = lastItem.raw.trimEnd();\n lastItem.text = lastItem.text.trimEnd();\n } else {\n // not a list since there were no items\n return;\n }\n list.raw = list.raw.trimEnd();\n\n // Item child tokens handled here at end because we needed to have the final item to trim it first\n for (const item of list.items) {\n this.lexer.state.top = false;\n item.tokens = this.lexer.blockTokens(item.text, []);\n const itemToken = item.tokens[0];\n if (item.task && (itemToken?.type === 'text' || itemToken?.type === 'paragraph')) {\n // Remove checkbox markdown from item tokens\n item.text = item.text.replace(this.rules.other.listReplaceTask, '');\n itemToken.raw = itemToken.raw.replace(this.rules.other.listReplaceTask, '');\n itemToken.text = itemToken.text.replace(this.rules.other.listReplaceTask, '');\n for (let i = this.lexer.inlineQueue.length - 1; i >= 0; i--) {\n if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[i].src)) {\n this.lexer.inlineQueue[i].src = this.lexer.inlineQueue[i].src.replace(this.rules.other.listReplaceTask, '');\n break;\n }\n }\n\n const taskRaw = this.rules.other.listTaskCheckbox.exec(item.raw);\n if (taskRaw) {\n const checkboxToken: Tokens.Checkbox = {\n type: 'checkbox',\n raw: taskRaw[0] + ' ',\n checked: taskRaw[0] !== '[ ]',\n };\n item.checked = checkboxToken.checked;\n if (list.loose) {\n if (item.tokens[0] && ['paragraph', 'text'].includes(item.tokens[0].type) && 'tokens' in item.tokens[0] && item.tokens[0].tokens) {\n item.tokens[0].raw = checkboxToken.raw + item.tokens[0].raw;\n item.tokens[0].text = checkboxToken.raw + item.tokens[0].text;\n item.tokens[0].tokens.unshift(checkboxToken);\n } else {\n item.tokens.unshift({\n type: 'paragraph',\n raw: checkboxToken.raw,\n text: checkboxToken.raw,\n tokens: [checkboxToken],\n });\n }\n } else {\n item.tokens.unshift(checkboxToken);\n }\n }\n } else if (item.task) {\n item.task = false;\n }\n\n if (!list.loose) {\n // Check if list should be loose\n const spacers = item.tokens.filter(t => t.type === 'space');\n const hasMultipleLineBreaks = spacers.length > 0 && spacers.some(t => this.rules.other.anyLine.test(t.raw));\n\n list.loose = hasMultipleLineBreaks;\n }\n }\n\n // Set all items to loose if list is loose\n if (list.loose) {\n for (const item of list.items) {\n item.loose = true;\n for (const token of item.tokens) {\n if (token.type === 'text') {\n token.type = 'paragraph';\n }\n }\n }\n }\n\n return list;\n }\n }\n\n html(src: string): Tokens.HTML | undefined {\n const cap = this.rules.block.html.exec(src);\n if (cap) {\n const raw = trimTrailingBlankLines(cap[0]);\n const token: Tokens.HTML = {\n type: 'html',\n block: true,\n raw,\n pre: cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style',\n text: raw,\n };\n return token;\n }\n }\n\n def(src: string): Tokens.Def | undefined {\n const cap = this.rules.block.def.exec(src);\n if (cap) {\n const tag = cap[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, ' ');\n const href = cap[2] ? cap[2].replace(this.rules.other.hrefBrackets, '$1').replace(this.rules.inline.anyPunctuation, '$1') : '';\n const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, '$1') : cap[3];\n return {\n type: 'def',\n tag,\n raw: rtrim(cap[0], '\\n'),\n href,\n title,\n };\n }\n }\n\n table(src: string): Tokens.Table | undefined {\n const cap = this.rules.block.table.exec(src);\n if (!cap) {\n return;\n }\n\n if (!this.rules.other.tableDelimiter.test(cap[2])) {\n // delimiter row must have a pipe (|) or colon (:) otherwise it is a setext heading\n return;\n }\n\n const headers = splitCells(cap[1]);\n const aligns = cap[2].replace(this.rules.other.tableAlignChars, '').split('|');\n const rows = cap[3]?.trim() ? cap[3].replace(this.rules.other.tableRowBlankLine, '').split('\\n') : [];\n\n const item: Tokens.Table = {\n type: 'table',\n raw: rtrim(cap[0], '\\n'),\n header: [],\n align: [],\n rows: [],\n };\n\n if (headers.length !== aligns.length) {\n // header and align columns must be equal, rows can be different.\n return;\n }\n\n for (const align of aligns) {\n if (this.rules.other.tableAlignRight.test(align)) {\n item.align.push('right');\n } else if (this.rules.other.tableAlignCenter.test(align)) {\n item.align.push('center');\n } else if (this.rules.other.tableAlignLeft.test(align)) {\n item.align.push('left');\n } else {\n item.align.push(null);\n }\n }\n\n for (let i = 0; i < headers.length; i++) {\n item.header.push({\n text: headers[i],\n tokens: this.lexer.inline(headers[i]),\n header: true,\n align: item.align[i],\n });\n }\n\n for (const row of rows) {\n item.rows.push(splitCells(row, item.header.length).map((cell, i) => {\n return {\n text: cell,\n tokens: this.lexer.inline(cell),\n header: false,\n align: item.align[i],\n };\n }));\n }\n\n return item;\n }\n\n lheading(src: string): Tokens.Heading | undefined {\n const cap = this.rules.block.lheading.exec(src);\n if (cap) {\n const text = cap[1].trim();\n return {\n type: 'heading',\n raw: rtrim(cap[0], '\\n'),\n depth: cap[2].charAt(0) === '=' ? 1 : 2,\n text,\n tokens: this.lexer.inline(text),\n };\n }\n }\n\n paragraph(src: string): Tokens.Paragraph | undefined {\n const cap = this.rules.block.paragraph.exec(src);\n if (cap) {\n const text = cap[1].charAt(cap[1].length - 1) === '\\n'\n ? cap[1].slice(0, -1)\n : cap[1];\n return {\n type: 'paragraph',\n raw: cap[0],\n text,\n tokens: this.lexer.inline(text),\n };\n }\n }\n\n text(src: string): Tokens.Text | undefined {\n const cap = this.rules.block.text.exec(src);\n if (cap) {\n return {\n type: 'text',\n raw: cap[0],\n text: cap[0],\n tokens: this.lexer.inline(cap[0]),\n };\n }\n }\n\n escape(src: string): Tokens.Escape | undefined {\n const cap = this.rules.inline.escape.exec(src);\n if (cap) {\n return {\n type: 'escape',\n raw: cap[0],\n text: cap[1],\n };\n }\n }\n\n tag(src: string): Tokens.Tag | undefined {\n const cap = this.rules.inline.tag.exec(src);\n if (cap) {\n if (!this.lexer.state.inLink && this.rules.other.startATag.test(cap[0])) {\n this.lexer.state.inLink = true;\n } else if (this.lexer.state.inLink && this.rules.other.endATag.test(cap[0])) {\n this.lexer.state.inLink = false;\n }\n if (!this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(cap[0])) {\n this.lexer.state.inRawBlock = true;\n } else if (this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(cap[0])) {\n this.lexer.state.inRawBlock = false;\n }\n\n return {\n type: 'html',\n raw: cap[0],\n inLink: this.lexer.state.inLink,\n inRawBlock: this.lexer.state.inRawBlock,\n block: false,\n text: cap[0],\n };\n }\n }\n\n link(src: string): Tokens.Link | Tokens.Image | undefined {\n const cap = this.rules.inline.link.exec(src);\n if (cap) {\n const trimmedUrl = cap[2].trim();\n if (!this.options.pedantic && this.rules.other.startAngleBracket.test(trimmedUrl)) {\n // commonmark requires matching angle brackets\n if (!(this.rules.other.endAngleBracket.test(trimmedUrl))) {\n return;\n }\n\n // ending angle bracket cannot be escaped\n const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\\\');\n if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {\n return;\n }\n } else {\n // find closing parenthesis\n const lastParenIndex = findClosingBracket(cap[2], '()');\n if (lastParenIndex === -2) {\n // more open parens than closed\n return;\n }\n\n if (lastParenIndex > -1) {\n const start = cap[0].indexOf('!') === 0 ? 5 : 4;\n const linkLen = start + cap[1].length + lastParenIndex;\n cap[2] = cap[2].substring(0, lastParenIndex);\n cap[0] = cap[0].substring(0, linkLen).trim();\n cap[3] = '';\n }\n }\n let href = cap[2];\n let title = '';\n if (this.options.pedantic) {\n // split pedantic href and title\n const link = this.rules.other.pedanticHrefTitle.exec(href);\n\n if (link) {\n href = link[1];\n title = link[3];\n }\n } else {\n title = cap[3] ? cap[3].slice(1, -1) : '';\n }\n\n href = href.trim();\n if (this.rules.other.startAngleBracket.test(href)) {\n if (this.options.pedantic && !(this.rules.other.endAngleBracket.test(trimmedUrl))) {\n // pedantic allows starting angle bracket without ending angle bracket\n href = href.slice(1);\n } else {\n href = href.slice(1, -1);\n }\n }\n return outputLink(cap, {\n href: href ? href.replace(this.rules.inline.anyPunctuation, '$1') : href,\n title: title ? title.replace(this.rules.inline.anyPunctuation, '$1') : title,\n }, cap[0], this.lexer, this.rules);\n }\n }\n\n reflink(src: string, links: Links): Tokens.Link | Tokens.Image | Tokens.Text | undefined {\n let cap;\n if ((cap = this.rules.inline.reflink.exec(src))\n || (cap = this.rules.inline.nolink.exec(src))) {\n const linkString = (cap[2] || cap[1]).replace(this.rules.other.multipleSpaceGlobal, ' ');\n const link = links[linkString.toLowerCase()];\n if (!link) {\n const text = cap[0].charAt(0);\n return {\n type: 'text',\n raw: text,\n text,\n };\n }\n return outputLink(cap, link, cap[0], this.lexer, this.rules);\n }\n }\n\n emStrong(src: string, maskedSrc: string, prevChar = ''): Tokens.Em | Tokens.Strong | undefined {\n let match = this.rules.inline.emStrongLDelim.exec(src);\n if (!match) return;\n if (!match[1] && !match[2] && !match[3] && !match[4]) return;\n\n // _ can't be between two alphanumerics. \\p{L}\\p{N} includes non-english alphabet/numbers as well\n if (match[4] && prevChar.match(this.rules.other.unicodeAlphaNumeric)) return;\n\n const nextChar = match[1] || match[3] || '';\n\n if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {\n // unicode Regex counts emoji as 1 char; spread into array for proper count (used multiple times below)\n const lLength = [...match[0]].length - 1;\n let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;\n\n const endReg = match[0][0] === '*' ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;\n endReg.lastIndex = 0;\n\n // Clip maskedSrc to same section of string as src (move to lexer?)\n maskedSrc = maskedSrc.slice(-1 * src.length + lLength);\n\n while ((match = endReg.exec(maskedSrc)) !== null) {\n rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];\n\n if (!rDelim) continue; // skip single * in __abc*abc__\n\n rLength = [...rDelim].length;\n\n if (match[3] || match[4]) { // found another Left Delim\n delimTotal += rLength;\n continue;\n } else if (match[5] || match[6]) { // either Left or Right Delim\n if (lLength % 3 && !((lLength + rLength) % 3)) {\n midDelimTotal += rLength;\n continue; // CommonMark Emphasis Rules 9-10\n }\n }\n\n delimTotal -= rLength;\n\n if (delimTotal > 0) continue; // Haven't found enough closing delimiters\n\n // Remove extra characters. *a*** -> *a*\n rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);\n // char length can be >1 for unicode characters;\n const lastCharLength = [...match[0]][0].length;\n const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);\n\n // Create `em` if smallest delimiter has odd char count. *a***\n if (Math.min(lLength, rLength) % 2) {\n const text = raw.slice(1, -1);\n return {\n type: 'em',\n raw,\n text,\n tokens: this.lexer.inlineTokens(text),\n };\n }\n\n // Create 'strong' if smallest delimiter has even char count. **a***\n const text = raw.slice(2, -2);\n return {\n type: 'strong',\n raw,\n text,\n tokens: this.lexer.inlineTokens(text),\n };\n }\n }\n }\n\n codespan(src: string): Tokens.Codespan | undefined {\n const cap = this.rules.inline.code.exec(src);\n if (cap) {\n let text = cap[2].replace(this.rules.other.newLineCharGlobal, ' ');\n const hasNonSpaceChars = this.rules.other.nonSpaceChar.test(text);\n const hasSpaceCharsOnBothEnds = this.rules.other.startingSpaceChar.test(text) && this.rules.other.endingSpaceChar.test(text);\n if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {\n text = text.substring(1, text.length - 1);\n }\n return {\n type: 'codespan',\n raw: cap[0],\n text,\n };\n }\n }\n\n br(src: string): Tokens.Br | undefined {\n const cap = this.rules.inline.br.exec(src);\n if (cap) {\n return {\n type: 'br',\n raw: cap[0],\n };\n }\n }\n\n del(src: string, maskedSrc: string, prevChar = ''): Tokens.Del | undefined {\n let match = this.rules.inline.delLDelim.exec(src);\n if (!match) return;\n\n const nextChar = match[1] || '';\n\n if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {\n // unicode Regex counts emoji as 1 char; spread into array for proper count\n const lLength = [...match[0]].length - 1;\n let rDelim, rLength, delimTotal = lLength;\n\n const endReg = this.rules.inline.delRDelim;\n endReg.lastIndex = 0;\n\n // Clip maskedSrc to same section of string as src\n maskedSrc = maskedSrc.slice(-1 * src.length + lLength);\n\n while ((match = endReg.exec(maskedSrc)) !== null) {\n rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];\n\n if (!rDelim) continue;\n\n rLength = [...rDelim].length;\n\n if (rLength !== lLength) continue;\n\n if (match[3] || match[4]) { // found another Left Delim\n delimTotal += rLength;\n continue;\n }\n\n delimTotal -= rLength;\n\n if (delimTotal > 0) continue; // Haven't found enough closing delimiters\n\n // Remove extra characters\n rLength = Math.min(rLength, rLength + delimTotal);\n // char length can be >1 for unicode characters\n const lastCharLength = [...match[0]][0].length;\n const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);\n\n // Create del token - only single ~ or double ~~ supported\n const text = raw.slice(lLength, -lLength);\n return {\n type: 'del',\n raw,\n text,\n tokens: this.lexer.inlineTokens(text),\n };\n }\n }\n }\n\n autolink(src: string): Tokens.Link | undefined {\n const cap = this.rules.inline.autolink.exec(src);\n if (cap) {\n let text, href;\n if (cap[2] === '@') {\n text = cap[1];\n href = 'mailto:' + text;\n } else {\n text = cap[1];\n href = text;\n }\n\n return {\n type: 'link',\n raw: cap[0],\n text,\n href,\n tokens: [\n {\n type: 'text',\n raw: text,\n text,\n },\n ],\n };\n }\n }\n\n url(src: string): Tokens.Link | undefined {\n let cap;\n if (cap = this.rules.inline.url.exec(src)) {\n let text, href;\n if (cap[2] === '@') {\n text = cap[0];\n href = 'mailto:' + text;\n } else {\n // do extended autolink path validation\n let prevCapZero;\n do {\n prevCapZero = cap[0];\n cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? '';\n } while (prevCapZero !== cap[0]);\n text = cap[0];\n if (cap[1] === 'www.') {\n href = 'http://' + cap[0];\n } else {\n href = cap[0];\n }\n }\n return {\n type: 'link',\n raw: cap[0],\n text,\n href,\n tokens: [\n {\n type: 'text',\n raw: text,\n text,\n },\n ],\n };\n }\n }\n\n inlineText(src: string): Tokens.Text | undefined {\n const cap = this.rules.inline.text.exec(src);\n if (cap) {\n const escaped = this.lexer.state.inRawBlock;\n return {\n type: 'text',\n raw: cap[0],\n text: cap[0],\n escaped,\n };\n }\n }\n}\n", "import { _Tokenizer } from './Tokenizer.ts';\nimport { _defaults } from './defaults.ts';\nimport { other, block, inline } from './rules.ts';\nimport type { Token, TokensList, Tokens } from './Tokens.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\n\n/**\n * Block Lexer\n */\nexport class _Lexer {\n tokens: TokensList;\n options: MarkedOptions;\n state: {\n inLink: boolean;\n inRawBlock: boolean;\n top: boolean;\n };\n\n public inlineQueue: { src: string, tokens: Token[] }[];\n\n private tokenizer: _Tokenizer;\n\n constructor(options?: MarkedOptions) {\n // TokenList cannot be created in one go\n this.tokens = [] as unknown as TokensList;\n this.tokens.links = Object.create(null);\n this.options = options || _defaults;\n this.options.tokenizer = this.options.tokenizer || new _Tokenizer();\n this.tokenizer = this.options.tokenizer;\n this.tokenizer.options = this.options;\n this.tokenizer.lexer = this;\n this.inlineQueue = [];\n this.state = {\n inLink: false,\n inRawBlock: false,\n top: true,\n };\n\n const rules = {\n other,\n block: block.normal,\n inline: inline.normal,\n };\n\n if (this.options.pedantic) {\n rules.block = block.pedantic;\n rules.inline = inline.pedantic;\n } else if (this.options.gfm) {\n rules.block = block.gfm;\n if (this.options.breaks) {\n rules.inline = inline.breaks;\n } else {\n rules.inline = inline.gfm;\n }\n }\n this.tokenizer.rules = rules;\n }\n\n /**\n * Expose Rules\n */\n static get rules() {\n return {\n block,\n inline,\n };\n }\n\n /**\n * Static Lex Method\n */\n static lex(src: string, options?: MarkedOptions) {\n const lexer = new _Lexer(options);\n return lexer.lex(src);\n }\n\n /**\n * Static Lex Inline Method\n */\n static lexInline(src: string, options?: MarkedOptions) {\n const lexer = new _Lexer(options);\n return lexer.inlineTokens(src);\n }\n\n /**\n * Preprocessing\n */\n lex(src: string) {\n src = src.replace(other.carriageReturn, '\\n');\n\n this.blockTokens(src, this.tokens);\n\n for (let i = 0; i < this.inlineQueue.length; i++) {\n const next = this.inlineQueue[i];\n this.inlineTokens(next.src, next.tokens);\n }\n this.inlineQueue = [];\n\n return this.tokens;\n }\n\n /**\n * Lexing\n */\n blockTokens(src: string, tokens?: Token[], lastParagraphClipped?: boolean): Token[];\n blockTokens(src: string, tokens?: TokensList, lastParagraphClipped?: boolean): TokensList;\n blockTokens(src: string, tokens: Token[] = [], lastParagraphClipped = false) {\n this.tokenizer.lexer = this;\n if (this.options.pedantic) {\n src = src.replace(other.tabCharGlobal, ' ').replace(other.spaceLine, '');\n }\n\n let srcLength = Infinity;\n while (src) {\n if (src.length < srcLength) {\n srcLength = src.length;\n } else {\n this.infiniteLoopError(src.charCodeAt(0));\n break;\n }\n\n let token: Tokens.Generic | undefined;\n\n if (this.options.extensions?.block?.some((extTokenizer) => {\n if (token = extTokenizer.call({ lexer: this }, src, tokens)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n return true;\n }\n return false;\n })) {\n continue;\n }\n\n // newline\n if (token = this.tokenizer.space(src)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n if (token.raw.length === 1 && lastToken !== undefined) {\n // if there's a single \\n as a spacer, it's terminating the last line,\n // so move it there so that we don't get unnecessary paragraph tags\n lastToken.raw += '\\n';\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n // code\n if (token = this.tokenizer.code(src)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n // An indented code block cannot interrupt a paragraph.\n if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {\n lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n lastToken.text += '\\n' + token.text;\n this.inlineQueue.at(-1)!.src = lastToken.text;\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n // fences\n if (token = this.tokenizer.fences(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // heading\n if (token = this.tokenizer.heading(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // hr\n if (token = this.tokenizer.hr(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // blockquote\n if (token = this.tokenizer.blockquote(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // list\n if (token = this.tokenizer.list(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // html\n if (token = this.tokenizer.html(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // def\n if (token = this.tokenizer.def(src)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {\n lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n lastToken.text += '\\n' + token.raw;\n this.inlineQueue.at(-1)!.src = lastToken.text;\n } else if (!this.tokens.links[token.tag]) {\n this.tokens.links[token.tag] = {\n href: token.href,\n title: token.title,\n };\n tokens.push(token);\n }\n continue;\n }\n\n // table (gfm)\n if (token = this.tokenizer.table(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // lheading\n if (token = this.tokenizer.lheading(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // top-level paragraph\n // prevent paragraph consuming extensions by clipping 'src' to extension start\n let cutSrc = src;\n if (this.options.extensions?.startBlock) {\n let startIndex = Infinity;\n const tempSrc = src.slice(1);\n let tempStart;\n this.options.extensions.startBlock.forEach((getStartIndex) => {\n tempStart = getStartIndex.call({ lexer: this }, tempSrc);\n if (typeof tempStart === 'number' && tempStart >= 0) {\n startIndex = Math.min(startIndex, tempStart);\n }\n });\n if (startIndex < Infinity && startIndex >= 0) {\n cutSrc = src.substring(0, startIndex + 1);\n }\n }\n if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {\n const lastToken = tokens.at(-1);\n if (lastParagraphClipped && lastToken?.type === 'paragraph') {\n lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n lastToken.text += '\\n' + token.text;\n this.inlineQueue.pop();\n this.inlineQueue.at(-1)!.src = lastToken.text;\n } else {\n tokens.push(token);\n }\n lastParagraphClipped = cutSrc.length !== src.length;\n src = src.substring(token.raw.length);\n continue;\n }\n\n // text\n if (token = this.tokenizer.text(src)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n if (lastToken?.type === 'text') {\n lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n lastToken.text += '\\n' + token.text;\n this.inlineQueue.pop();\n this.inlineQueue.at(-1)!.src = lastToken.text;\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n if (src) {\n this.infiniteLoopError(src.charCodeAt(0));\n break;\n }\n }\n\n this.state.top = true;\n return tokens;\n }\n\n inline(src: string, tokens: Token[] = []) {\n this.inlineQueue.push({ src, tokens });\n return tokens;\n }\n\n /**\n * Lexing/Compiling\n */\n inlineTokens(src: string, tokens: Token[] = []): Token[] {\n this.tokenizer.lexer = this;\n // String with links masked to avoid interference with em and strong\n let maskedSrc = src;\n let match: RegExpExecArray | null = null;\n\n // Mask out reflinks\n if (this.tokens.links) {\n const links = Object.keys(this.tokens.links);\n if (links.length > 0) {\n while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) !== null) {\n if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {\n maskedSrc = maskedSrc.slice(0, match.index)\n + '[' + 'a'.repeat(match[0].length - 2) + ']'\n + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);\n }\n }\n }\n }\n\n // Mask out escaped characters\n while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) !== null) {\n maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);\n }\n\n // Mask out other blocks\n let offset;\n while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) !== null) {\n offset = match[2] ? match[2].length : 0;\n maskedSrc = maskedSrc.slice(0, match.index + offset) + '[' + 'a'.repeat(match[0].length - offset - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);\n }\n\n // Mask out blocks from extensions\n maskedSrc = this.options.hooks?.emStrongMask?.call({ lexer: this }, maskedSrc) ?? maskedSrc;\n\n let keepPrevChar = false;\n let prevChar = '';\n let srcLength = Infinity;\n while (src) {\n if (src.length < srcLength) {\n srcLength = src.length;\n } else {\n this.infiniteLoopError(src.charCodeAt(0));\n break;\n }\n\n if (!keepPrevChar) {\n prevChar = '';\n }\n keepPrevChar = false;\n\n let token: Tokens.Generic | undefined;\n\n // extensions\n if (this.options.extensions?.inline?.some((extTokenizer) => {\n if (token = extTokenizer.call({ lexer: this }, src, tokens)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n return true;\n }\n return false;\n })) {\n continue;\n }\n\n // escape\n if (token = this.tokenizer.escape(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // tag\n if (token = this.tokenizer.tag(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // link\n if (token = this.tokenizer.link(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // reflink, nolink\n if (token = this.tokenizer.reflink(src, this.tokens.links)) {\n src = src.substring(token.raw.length);\n const lastToken = tokens.at(-1);\n if (token.type === 'text' && lastToken?.type === 'text') {\n lastToken.raw += token.raw;\n lastToken.text += token.text;\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n // em & strong\n if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // code\n if (token = this.tokenizer.codespan(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // br\n if (token = this.tokenizer.br(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // del (gfm)\n if (token = this.tokenizer.del(src, maskedSrc, prevChar)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // autolink\n if (token = this.tokenizer.autolink(src)) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // url (gfm)\n if (!this.state.inLink && (token = this.tokenizer.url(src))) {\n src = src.substring(token.raw.length);\n tokens.push(token);\n continue;\n }\n\n // text\n // prevent inlineText consuming extensions by clipping 'src' to extension start\n let cutSrc = src;\n if (this.options.extensions?.startInline) {\n let startIndex = Infinity;\n const tempSrc = src.slice(1);\n let tempStart;\n this.options.extensions.startInline.forEach((getStartIndex) => {\n tempStart = getStartIndex.call({ lexer: this }, tempSrc);\n if (typeof tempStart === 'number' && tempStart >= 0) {\n startIndex = Math.min(startIndex, tempStart);\n }\n });\n if (startIndex < Infinity && startIndex >= 0) {\n cutSrc = src.substring(0, startIndex + 1);\n }\n }\n if (token = this.tokenizer.inlineText(cutSrc)) {\n src = src.substring(token.raw.length);\n if (token.raw.slice(-1) !== '_') { // Track prevChar before string of ____ started\n prevChar = token.raw.slice(-1);\n }\n keepPrevChar = true;\n const lastToken = tokens.at(-1);\n if (lastToken?.type === 'text') {\n lastToken.raw += token.raw;\n lastToken.text += token.text;\n } else {\n tokens.push(token);\n }\n continue;\n }\n\n if (src) {\n this.infiniteLoopError(src.charCodeAt(0));\n break;\n }\n }\n\n return tokens;\n }\n\n private infiniteLoopError(byte: number) {\n const errMsg = 'Infinite loop on byte: ' + byte;\n if (this.options.silent) {\n console.error(errMsg);\n } else {\n throw new Error(errMsg);\n }\n }\n}\n", "import { _defaults } from './defaults.ts';\nimport {\n cleanUrl,\n escapeHtmlEntities,\n} from './helpers.ts';\nimport { other } from './rules.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\nimport type { Tokens } from './Tokens.ts';\nimport type { _Parser } from './Parser.ts';\n\n/**\n * Renderer\n */\nexport class _Renderer {\n options: MarkedOptions;\n parser!: _Parser; // set by the parser\n constructor(options?: MarkedOptions) {\n this.options = options || _defaults;\n }\n\n space(token: Tokens.Space): RendererOutput {\n return '' as RendererOutput;\n }\n\n code({ text, lang, escaped }: Tokens.Code): RendererOutput {\n const langString = (lang || '').match(other.notSpaceStart)?.[0];\n\n const code = text.replace(other.endingNewline, '') + '\\n';\n\n if (!langString) {\n return '
    '\n        + (escaped ? code : escapeHtmlEntities(code, true))\n        + '
    \\n' as RendererOutput;\n }\n\n return '
    '\n      + (escaped ? code : escapeHtmlEntities(code, true))\n      + '
    \\n' as RendererOutput;\n }\n\n blockquote({ tokens }: Tokens.Blockquote): RendererOutput {\n const body = this.parser.parse(tokens);\n return `
    \\n${body}
    \\n` as RendererOutput;\n }\n\n html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput {\n return text as RendererOutput;\n }\n\n def(token: Tokens.Def): RendererOutput {\n return '' as RendererOutput;\n }\n\n heading({ tokens, depth }: Tokens.Heading): RendererOutput {\n return `${this.parser.parseInline(tokens)}\\n` as RendererOutput;\n }\n\n hr(token: Tokens.Hr): RendererOutput {\n return '
    \\n' as RendererOutput;\n }\n\n list(token: Tokens.List): RendererOutput {\n const ordered = token.ordered;\n const start = token.start;\n\n let body = '';\n for (let j = 0; j < token.items.length; j++) {\n const item = token.items[j];\n body += this.listitem(item);\n }\n\n const type = ordered ? 'ol' : 'ul';\n const startAttr = (ordered && start !== 1) ? (' start=\"' + start + '\"') : '';\n return '<' + type + startAttr + '>\\n' + body + '\\n' as RendererOutput;\n }\n\n listitem(item: Tokens.ListItem): RendererOutput {\n return `
  • ${this.parser.parse(item.tokens)}
    • \\n` as RendererOutput;\n }\n\n checkbox({ checked }: Tokens.Checkbox): RendererOutput {\n return ' ' as RendererOutput;\n }\n\n paragraph({ tokens }: Tokens.Paragraph): RendererOutput {\n return `

    ${this.parser.parseInline(tokens)}

    \\n` as RendererOutput;\n }\n\n table(token: Tokens.Table): RendererOutput {\n let header = '';\n\n // header\n let cell = '';\n for (let j = 0; j < token.header.length; j++) {\n cell += this.tablecell(token.header[j]);\n }\n header += this.tablerow({ text: cell as ParserOutput });\n\n let body = '';\n for (let j = 0; j < token.rows.length; j++) {\n const row = token.rows[j];\n\n cell = '';\n for (let k = 0; k < row.length; k++) {\n cell += this.tablecell(row[k]);\n }\n\n body += this.tablerow({ text: cell as ParserOutput });\n }\n if (body) body = `${body}`;\n\n return '\\n'\n + '\\n'\n + header\n + '\\n'\n + body\n + '
    \\n' as RendererOutput;\n }\n\n tablerow({ text }: Tokens.TableRow): RendererOutput {\n return `\\n${text}\\n` as RendererOutput;\n }\n\n tablecell(token: Tokens.TableCell): RendererOutput {\n const content = this.parser.parseInline(token.tokens);\n const type = token.header ? 'th' : 'td';\n const tag = token.align\n ? `<${type} align=\"${token.align}\">`\n : `<${type}>`;\n return tag + content + `\\n` as RendererOutput;\n }\n\n /**\n * span level renderer\n */\n strong({ tokens }: Tokens.Strong): RendererOutput {\n return `${this.parser.parseInline(tokens)}` as RendererOutput;\n }\n\n em({ tokens }: Tokens.Em): RendererOutput {\n return `${this.parser.parseInline(tokens)}` as RendererOutput;\n }\n\n codespan({ text }: Tokens.Codespan): RendererOutput {\n return `${escapeHtmlEntities(text, true)}` as RendererOutput;\n }\n\n br(token: Tokens.Br): RendererOutput {\n return '
    ' as RendererOutput;\n }\n\n del({ tokens }: Tokens.Del): RendererOutput {\n return `${this.parser.parseInline(tokens)}` as RendererOutput;\n }\n\n link({ href, title, tokens }: Tokens.Link): RendererOutput {\n const text = this.parser.parseInline(tokens) as string;\n const cleanHref = cleanUrl(href);\n if (cleanHref === null) {\n return text as RendererOutput;\n }\n href = cleanHref;\n let out = '    ';\n return out as RendererOutput;\n }\n\n image({ href, title, text, tokens }: Tokens.Image): RendererOutput {\n if (tokens) {\n text = this.parser.parseInline(tokens, this.parser.textRenderer) as string;\n }\n const cleanHref = cleanUrl(href);\n if (cleanHref === null) {\n return escapeHtmlEntities(text) as RendererOutput;\n }\n href = cleanHref;\n\n let out = `\"${escapeHtmlEntities(text)}\"`;\n {\n // no need for block level renderers\n strong({ text }: Tokens.Strong): RendererOutput {\n return text as RendererOutput;\n }\n\n em({ text }: Tokens.Em): RendererOutput {\n return text as RendererOutput;\n }\n\n codespan({ text }: Tokens.Codespan): RendererOutput {\n return text as RendererOutput;\n }\n\n del({ text }: Tokens.Del): RendererOutput {\n return text as RendererOutput;\n }\n\n html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput {\n return text as RendererOutput;\n }\n\n text({ text }: Tokens.Text | Tokens.Escape | Tokens.Tag): RendererOutput {\n return text as RendererOutput;\n }\n\n link({ text }: Tokens.Link): RendererOutput {\n return '' + text as RendererOutput;\n }\n\n image({ text }: Tokens.Image): RendererOutput {\n return '' + text as RendererOutput;\n }\n\n br(): RendererOutput {\n return '' as RendererOutput;\n }\n\n checkbox({ raw }: Tokens.Checkbox): RendererOutput {\n return raw as RendererOutput;\n }\n}\n", "import { _Renderer } from './Renderer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { _defaults } from './defaults.ts';\nimport type { MarkedToken, Token, Tokens } from './Tokens.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\n\n/**\n * Parsing & Compiling\n */\nexport class _Parser {\n options: MarkedOptions;\n renderer: _Renderer;\n textRenderer: _TextRenderer;\n constructor(options?: MarkedOptions) {\n this.options = options || _defaults;\n this.options.renderer = this.options.renderer || new _Renderer();\n this.renderer = this.options.renderer;\n this.renderer.options = this.options;\n this.renderer.parser = this;\n this.textRenderer = new _TextRenderer();\n }\n\n /**\n * Static Parse Method\n */\n static parse(tokens: Token[], options?: MarkedOptions) {\n const parser = new _Parser(options);\n return parser.parse(tokens);\n }\n\n /**\n * Static Parse Inline Method\n */\n static parseInline(tokens: Token[], options?: MarkedOptions) {\n const parser = new _Parser(options);\n return parser.parseInline(tokens);\n }\n\n /**\n * Parse Loop\n */\n parse(tokens: Token[]): ParserOutput {\n this.renderer.parser = this;\n let out = '';\n\n for (let i = 0; i < tokens.length; i++) {\n const anyToken = tokens[i];\n\n // Run any renderer extensions\n if (this.options.extensions?.renderers?.[anyToken.type]) {\n const genericToken = anyToken as Tokens.Generic;\n const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);\n if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'def', 'paragraph', 'text'].includes(genericToken.type)) {\n out += ret || '';\n continue;\n }\n }\n\n const token = anyToken as MarkedToken;\n\n switch (token.type) {\n case 'space': {\n out += this.renderer.space(token);\n break;\n }\n case 'hr': {\n out += this.renderer.hr(token);\n break;\n }\n case 'heading': {\n out += this.renderer.heading(token);\n break;\n }\n case 'code': {\n out += this.renderer.code(token);\n break;\n }\n case 'table': {\n out += this.renderer.table(token);\n break;\n }\n case 'blockquote': {\n out += this.renderer.blockquote(token);\n break;\n }\n case 'list': {\n out += this.renderer.list(token);\n break;\n }\n case 'checkbox': {\n out += this.renderer.checkbox(token);\n break;\n }\n case 'html': {\n out += this.renderer.html(token);\n break;\n }\n case 'def': {\n out += this.renderer.def(token);\n break;\n }\n case 'paragraph': {\n out += this.renderer.paragraph(token);\n break;\n }\n case 'text': {\n out += this.renderer.text(token);\n break;\n }\n\n default: {\n const errMsg = 'Token with \"' + token.type + '\" type was not found.';\n if (this.options.silent) {\n console.error(errMsg);\n return '' as ParserOutput;\n } else {\n throw new Error(errMsg);\n }\n }\n }\n }\n\n return out as ParserOutput;\n }\n\n /**\n * Parse Inline Tokens\n */\n parseInline(tokens: Token[], renderer: _Renderer | _TextRenderer = this.renderer): ParserOutput {\n this.renderer.parser = this;\n let out = '';\n\n for (let i = 0; i < tokens.length; i++) {\n const anyToken = tokens[i];\n\n // Run any renderer extensions\n if (this.options.extensions?.renderers?.[anyToken.type]) {\n const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);\n if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(anyToken.type)) {\n out += ret || '';\n continue;\n }\n }\n\n const token = anyToken as MarkedToken;\n\n switch (token.type) {\n case 'escape': {\n out += renderer.text(token);\n break;\n }\n case 'html': {\n out += renderer.html(token);\n break;\n }\n case 'link': {\n out += renderer.link(token);\n break;\n }\n case 'image': {\n out += renderer.image(token);\n break;\n }\n case 'checkbox': {\n out += renderer.checkbox(token);\n break;\n }\n case 'strong': {\n out += renderer.strong(token);\n break;\n }\n case 'em': {\n out += renderer.em(token);\n break;\n }\n case 'codespan': {\n out += renderer.codespan(token);\n break;\n }\n case 'br': {\n out += renderer.br(token);\n break;\n }\n case 'del': {\n out += renderer.del(token);\n break;\n }\n case 'text': {\n out += renderer.text(token);\n break;\n }\n default: {\n const errMsg = 'Token with \"' + token.type + '\" type was not found.';\n if (this.options.silent) {\n console.error(errMsg);\n return '' as ParserOutput;\n } else {\n throw new Error(errMsg);\n }\n }\n }\n }\n return out as ParserOutput;\n }\n}\n", "import { _defaults } from './defaults.ts';\nimport { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\nimport type { Token, TokensList } from './Tokens.ts';\n\nexport class _Hooks {\n options: MarkedOptions;\n block?: boolean;\n\n constructor(options?: MarkedOptions) {\n this.options = options || _defaults;\n }\n\n static passThroughHooks = new Set([\n 'preprocess',\n 'postprocess',\n 'processAllTokens',\n 'emStrongMask',\n ]);\n\n static passThroughHooksRespectAsync = new Set([\n 'preprocess',\n 'postprocess',\n 'processAllTokens',\n ]);\n\n /**\n * Process markdown before marked\n */\n preprocess(markdown: string) {\n return markdown;\n }\n\n /**\n * Process HTML after marked is finished\n */\n postprocess(html: ParserOutput) {\n return html;\n }\n\n /**\n * Process all tokens before walk tokens\n */\n processAllTokens(tokens: Token[] | TokensList) {\n return tokens;\n }\n\n /**\n * Mask contents that should not be interpreted as em/strong delimiters\n */\n emStrongMask(src: string) {\n return src;\n }\n\n /**\n * Provide function to tokenize markdown\n */\n provideLexer(block = this.block) {\n return block ? _Lexer.lex : _Lexer.lexInline;\n }\n\n /**\n * Provide function to parse tokens\n */\n provideParser(block = this.block) {\n return block ? _Parser.parse : _Parser.parseInline;\n }\n}\n", "import { _getDefaults } from './defaults.ts';\nimport { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport { _Hooks } from './Hooks.ts';\nimport { _Renderer } from './Renderer.ts';\nimport { _Tokenizer } from './Tokenizer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { escapeHtmlEntities } from './helpers.ts';\nimport type { MarkedExtension, MarkedOptions } from './MarkedOptions.ts';\nimport type { Token, Tokens, TokensList } from './Tokens.ts';\n\nexport type MaybePromise = void | Promise;\n\ntype UnknownFunction = (...args: unknown[]) => unknown;\ntype GenericRendererFunction = (...args: unknown[]) => string | false;\n\nexport class Marked {\n defaults = _getDefaults();\n options = this.setOptions;\n\n parse = this.parseMarkdown(true);\n parseInline = this.parseMarkdown(false);\n\n Parser = _Parser;\n Renderer = _Renderer;\n TextRenderer = _TextRenderer;\n Lexer = _Lexer;\n Tokenizer = _Tokenizer;\n Hooks = _Hooks;\n\n constructor(...args: MarkedExtension[]) {\n this.use(...args);\n }\n\n /**\n * Run callback for every token\n */\n walkTokens(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) {\n let values: MaybePromise[] = [];\n for (const token of tokens) {\n values = values.concat(callback.call(this, token));\n switch (token.type) {\n case 'table': {\n const tableToken = token as Tokens.Table;\n for (const cell of tableToken.header) {\n values = values.concat(this.walkTokens(cell.tokens, callback));\n }\n for (const row of tableToken.rows) {\n for (const cell of row) {\n values = values.concat(this.walkTokens(cell.tokens, callback));\n }\n }\n break;\n }\n case 'list': {\n const listToken = token as Tokens.List;\n values = values.concat(this.walkTokens(listToken.items, callback));\n break;\n }\n default: {\n const genericToken = token as Tokens.Generic;\n if (this.defaults.extensions?.childTokens?.[genericToken.type]) {\n this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {\n const tokens = genericToken[childTokens].flat(Infinity) as Token[] | TokensList;\n values = values.concat(this.walkTokens(tokens, callback));\n });\n } else if (genericToken.tokens) {\n values = values.concat(this.walkTokens(genericToken.tokens, callback));\n }\n }\n }\n }\n return values;\n }\n\n use(...args: MarkedExtension[]) {\n const extensions: MarkedOptions['extensions'] = this.defaults.extensions || { renderers: {}, childTokens: {} };\n\n args.forEach((pack) => {\n // copy options to new object\n const opts = { ...pack } as MarkedOptions;\n\n // set async to true if it was set to true before\n opts.async = this.defaults.async || opts.async || false;\n\n // ==-- Parse \"addon\" extensions --== //\n if (pack.extensions) {\n pack.extensions.forEach((ext) => {\n if (!ext.name) {\n throw new Error('extension name required');\n }\n if ('renderer' in ext) { // Renderer extensions\n const prevRenderer = extensions.renderers[ext.name];\n if (prevRenderer) {\n // Replace extension with func to run new extension but fall back if false\n extensions.renderers[ext.name] = function(...args) {\n let ret = ext.renderer.apply(this, args);\n if (ret === false) {\n ret = prevRenderer.apply(this, args);\n }\n return ret;\n };\n } else {\n extensions.renderers[ext.name] = ext.renderer;\n }\n }\n if ('tokenizer' in ext) { // Tokenizer Extensions\n if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {\n throw new Error(\"extension level must be 'block' or 'inline'\");\n }\n const extLevel = extensions[ext.level];\n if (extLevel) {\n extLevel.unshift(ext.tokenizer);\n } else {\n extensions[ext.level] = [ext.tokenizer];\n }\n if (ext.start) { // Function to check for start of token\n if (ext.level === 'block') {\n if (extensions.startBlock) {\n extensions.startBlock.push(ext.start);\n } else {\n extensions.startBlock = [ext.start];\n }\n } else if (ext.level === 'inline') {\n if (extensions.startInline) {\n extensions.startInline.push(ext.start);\n } else {\n extensions.startInline = [ext.start];\n }\n }\n }\n }\n if ('childTokens' in ext && ext.childTokens) { // Child tokens to be visited by walkTokens\n extensions.childTokens[ext.name] = ext.childTokens;\n }\n });\n opts.extensions = extensions;\n }\n\n // ==-- Parse \"overwrite\" extensions --== //\n if (pack.renderer) {\n const renderer = this.defaults.renderer || new _Renderer(this.defaults);\n for (const prop in pack.renderer) {\n if (!(prop in renderer)) {\n throw new Error(`renderer '${prop}' does not exist`);\n }\n if (['options', 'parser'].includes(prop)) {\n // ignore options property\n continue;\n }\n const rendererProp = prop as Exclude, 'options' | 'parser'>;\n const rendererFunc = pack.renderer[rendererProp] as GenericRendererFunction;\n const prevRenderer = renderer[rendererProp] as GenericRendererFunction;\n // Replace renderer with func to run extension, but fall back if false\n renderer[rendererProp] = (...args: unknown[]) => {\n let ret = rendererFunc.apply(renderer, args);\n if (ret === false) {\n ret = prevRenderer.apply(renderer, args);\n }\n return (ret || '') as RendererOutput;\n };\n }\n opts.renderer = renderer;\n }\n if (pack.tokenizer) {\n const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);\n for (const prop in pack.tokenizer) {\n if (!(prop in tokenizer)) {\n throw new Error(`tokenizer '${prop}' does not exist`);\n }\n if (['options', 'rules', 'lexer'].includes(prop)) {\n // ignore options, rules, and lexer properties\n continue;\n }\n const tokenizerProp = prop as Exclude, 'options' | 'rules' | 'lexer'>;\n const tokenizerFunc = pack.tokenizer[tokenizerProp] as UnknownFunction;\n const prevTokenizer = tokenizer[tokenizerProp] as UnknownFunction;\n // Replace tokenizer with func to run extension, but fall back if false\n // @ts-expect-error cannot type tokenizer function dynamically\n tokenizer[tokenizerProp] = (...args: unknown[]) => {\n let ret = tokenizerFunc.apply(tokenizer, args);\n if (ret === false) {\n ret = prevTokenizer.apply(tokenizer, args);\n }\n return ret;\n };\n }\n opts.tokenizer = tokenizer;\n }\n\n // ==-- Parse Hooks extensions --== //\n if (pack.hooks) {\n const hooks = this.defaults.hooks || new _Hooks();\n for (const prop in pack.hooks) {\n if (!(prop in hooks)) {\n throw new Error(`hook '${prop}' does not exist`);\n }\n if (['options', 'block'].includes(prop)) {\n // ignore options and block properties\n continue;\n }\n const hooksProp = prop as Exclude, 'options' | 'block'>;\n const hooksFunc = pack.hooks[hooksProp] as UnknownFunction;\n const prevHook = hooks[hooksProp] as UnknownFunction;\n if (_Hooks.passThroughHooks.has(prop)) {\n // @ts-expect-error cannot type hook function dynamically\n hooks[hooksProp] = (arg: unknown) => {\n if (this.defaults.async && _Hooks.passThroughHooksRespectAsync.has(prop)) {\n return (async() => {\n const ret = await hooksFunc.call(hooks, arg);\n return prevHook.call(hooks, ret);\n })();\n }\n\n const ret = hooksFunc.call(hooks, arg);\n return prevHook.call(hooks, ret);\n };\n } else {\n // @ts-expect-error cannot type hook function dynamically\n hooks[hooksProp] = (...args: unknown[]) => {\n if (this.defaults.async) {\n return (async() => {\n let ret = await hooksFunc.apply(hooks, args);\n if (ret === false) {\n ret = await prevHook.apply(hooks, args);\n }\n return ret;\n })();\n }\n\n let ret = hooksFunc.apply(hooks, args);\n if (ret === false) {\n ret = prevHook.apply(hooks, args);\n }\n return ret;\n };\n }\n }\n opts.hooks = hooks;\n }\n\n // ==-- Parse WalkTokens extensions --== //\n if (pack.walkTokens) {\n const walkTokens = this.defaults.walkTokens;\n const packWalktokens = pack.walkTokens;\n opts.walkTokens = function(token) {\n let values: MaybePromise[] = [];\n values.push(packWalktokens.call(this, token));\n if (walkTokens) {\n values = values.concat(walkTokens.call(this, token));\n }\n return values;\n };\n }\n\n this.defaults = { ...this.defaults, ...opts };\n });\n\n return this;\n }\n\n setOptions(opt: MarkedOptions) {\n this.defaults = { ...this.defaults, ...opt };\n return this;\n }\n\n lexer(src: string, options?: MarkedOptions) {\n return _Lexer.lex(src, options ?? this.defaults);\n }\n\n parser(tokens: Token[], options?: MarkedOptions) {\n return _Parser.parse(tokens, options ?? this.defaults);\n }\n\n private parseMarkdown(blockType: boolean) {\n type overloadedParse = {\n (src: string, options: MarkedOptions & { async: true }): Promise;\n (src: string, options: MarkedOptions & { async: false }): ParserOutput;\n (src: string, options?: MarkedOptions | null): ParserOutput | Promise;\n };\n\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const parse: overloadedParse = (src: string, options?: MarkedOptions | null): any => {\n const origOpt = { ...options };\n const opt = { ...this.defaults, ...origOpt };\n\n const throwError = this.onError(!!opt.silent, !!opt.async);\n\n // throw error if an extension set async to true but parse was called with async: false\n if (this.defaults.async === true && origOpt.async === false) {\n return throwError(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.'));\n }\n\n // throw error in case of non string input\n if (typeof src === 'undefined' || src === null) {\n return throwError(new Error('marked(): input parameter is undefined or null'));\n }\n if (typeof src !== 'string') {\n return throwError(new Error('marked(): input parameter is of type '\n + Object.prototype.toString.call(src) + ', string expected'));\n }\n\n if (opt.hooks) {\n opt.hooks.options = opt;\n opt.hooks.block = blockType;\n }\n\n if (opt.async) {\n return (async() => {\n const processedSrc = opt.hooks ? await opt.hooks.preprocess(src) : src;\n const lexer = opt.hooks ? await opt.hooks.provideLexer(blockType) : (blockType ? _Lexer.lex : _Lexer.lexInline);\n const tokens = await lexer(processedSrc, opt);\n const processedTokens = opt.hooks ? await opt.hooks.processAllTokens(tokens) : tokens;\n if (opt.walkTokens) {\n await Promise.all(this.walkTokens(processedTokens, opt.walkTokens));\n }\n const parser = opt.hooks ? await opt.hooks.provideParser(blockType) : (blockType ? _Parser.parse : _Parser.parseInline);\n const html = await parser(processedTokens, opt);\n return opt.hooks ? await opt.hooks.postprocess(html) : html;\n })().catch(throwError);\n }\n\n try {\n if (opt.hooks) {\n src = opt.hooks.preprocess(src) as string;\n }\n const lexer = opt.hooks ? opt.hooks.provideLexer(blockType) : (blockType ? _Lexer.lex : _Lexer.lexInline);\n let tokens = lexer(src, opt);\n if (opt.hooks) {\n tokens = opt.hooks.processAllTokens(tokens);\n }\n if (opt.walkTokens) {\n this.walkTokens(tokens, opt.walkTokens);\n }\n const parser = opt.hooks ? opt.hooks.provideParser(blockType) : (blockType ? _Parser.parse : _Parser.parseInline);\n let html = parser(tokens, opt);\n if (opt.hooks) {\n html = opt.hooks.postprocess(html);\n }\n return html;\n } catch(e) {\n return throwError(e as Error);\n }\n };\n\n return parse;\n }\n\n private onError(silent: boolean, async: boolean) {\n return (e: Error): string | Promise => {\n e.message += '\\nPlease report this to https://github.com/markedjs/marked.';\n\n if (silent) {\n const msg = '

    An error occurred:

    '\n          + escapeHtmlEntities(e.message + '', true)\n          + '
    ';\n if (async) {\n return Promise.resolve(msg);\n }\n return msg;\n }\n\n if (async) {\n return Promise.reject(e);\n }\n throw e;\n };\n }\n}\n"], + "mappings": "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", + "names": ["marked_exports", "__export", "_Hooks", "_Lexer", "Marked", "_Parser", "_Renderer", "_TextRenderer", "_Tokenizer", "_defaults", "_getDefaults", "lexer", "marked", "options", "parse", "parseInline", "parser", "setOptions", "use", "walkTokens", "__toCommonJS", "_getDefaults", "_defaults", "changeDefaults", "newDefaults", "noopTest", "cachedIndentRegex", "createRegex", "cache", "indent", "cacheIndex", "regex", "edit", "opt", "source", "obj", "name", "val", "valSource", "other", "supportsLookbehind", "a", "bull", "newline", "blockCode", "fences", "hr", "heading", "bullet", "lheadingCore", "lheading", "lheadingGfm", "_paragraph", "blockText", "_blockLabel", "def", "list", "_tag", "_comment", "html", "paragraph", "blockquote", "blockNormal", "gfmTable", "blockGfm", "blockPedantic", "escape", "inlineCode", "br", "inlineText", "_punctuation", "_punctuationOrSpace", "_notPunctuationOrSpace", "punctuation", "_punctuationGfmStrongEm", "_punctuationOrSpaceGfmStrongEm", "_notPunctuationOrSpaceGfmStrongEm", "blockSkip", "emStrongLDelimCore", "emStrongLDelim", "emStrongLDelimGfm", "emStrongRDelimAstCore", "emStrongRDelimAst", "emStrongRDelimAstGfm", "emStrongRDelimUnd", "delLDelim", "delRDelimCore", "delRDelim", "anyPunctuation", "autolink", "_inlineComment", "tag", "_inlineLabel", "link", "reflink", "nolink", "reflinkSearch", "_caseInsensitiveProtocol", "inlineNormal", "inlinePedantic", "inlineGfm", "inlineBreaks", "block", "inline", "escapeReplacements", "getEscapeReplacement", "ch", "escapeHtmlEntities", "html", "encode", "other", "cleanUrl", "href", "splitCells", "tableRow", "count", "row", "match", "offset", "str", "escaped", "curr", "cells", "i", "rtrim", "c", "invert", "l", "suffLen", "currChar", "trimTrailingBlankLines", "lines", "end", "findClosingBracket", "b", "level", "expandTabs", "line", "indent", "col", "expanded", "char", "added", "outputLink", "cap", "link", "raw", "lexer", "rules", "href", "title", "text", "token", "indentCodeCompensation", "matchIndentToCode", "indentToCode", "node", "matchIndentInNode", "indentInNode", "_Tokenizer", "options", "_defaults", "src", "trimTrailingBlankLines", "trimmed", "rtrim", "lines", "tokens", "inBlockquote", "currentLines", "i", "currentRaw", "currentText", "top", "lastToken", "oldToken", "newText", "newToken", "bull", "isordered", "list", "itemRegex", "endsWithBlankLine", "endEarly", "itemContents", "line", "expandTabs", "nextLine", "blankLine", "indent", "nextBulletRegex", "hrRegex", "fencesBeginRegex", "headingBeginRegex", "htmlBeginRegex", "blockquoteBeginRegex", "rawLine", "nextLineWithoutTabs", "lastItem", "item", "itemToken", "taskRaw", "checkboxToken", "spacers", "t", "hasMultipleLineBreaks", "tag", "headers", "splitCells", "aligns", "rows", "align", "row", "cell", "trimmedUrl", "rtrimSlash", "lastParenIndex", "findClosingBracket", "linkLen", "links", "linkString", "maskedSrc", "prevChar", "match", "lLength", "rDelim", "rLength", "delimTotal", "midDelimTotal", "endReg", "lastCharLength", "hasNonSpaceChars", "hasSpaceCharsOnBothEnds", "prevCapZero", "escaped", "_Lexer", "__Lexer", "options", "_defaults", "_Tokenizer", "rules", "other", "block", "inline", "src", "i", "next", "tokens", "lastParagraphClipped", "srcLength", "token", "extTokenizer", "lastToken", "cutSrc", "startIndex", "tempSrc", "tempStart", "getStartIndex", "maskedSrc", "match", "links", "offset", "keepPrevChar", "prevChar", "byte", "errMsg", "_Renderer", "options", "_defaults", "token", "text", "lang", "escaped", "langString", "other", "code", "escapeHtmlEntities", "tokens", "depth", "ordered", "start", "body", "j", "item", "type", "startAttr", "checked", "header", "cell", "row", "k", "content", "href", "title", "cleanHref", "cleanUrl", "out", "_TextRenderer", "text", "raw", "_Parser", "__Parser", "options", "_defaults", "_Renderer", "_TextRenderer", "tokens", "out", "i", "anyToken", "genericToken", "ret", "token", "errMsg", "renderer", "_Hooks", "options", "_defaults", "markdown", "html", "tokens", "src", "block", "_Lexer", "_Parser", "Marked", "_getDefaults", "_Parser", "_Renderer", "_TextRenderer", "_Lexer", "_Tokenizer", "_Hooks", "args", "tokens", "callback", "values", "token", "tableToken", "cell", "row", "listToken", "genericToken", "childTokens", "extensions", "pack", "opts", "ext", "prevRenderer", "ret", "extLevel", "renderer", "prop", "rendererProp", "rendererFunc", "tokenizer", "tokenizerProp", "tokenizerFunc", "prevTokenizer", "hooks", "hooksProp", "hooksFunc", "prevHook", "arg", "walkTokens", "packWalktokens", "opt", "src", "options", "blockType", "origOpt", "throwError", "processedSrc", "processedTokens", "html", "e", "silent", "async", "msg", "escapeHtmlEntities", "markedInstance", "Marked", "marked", "src", "opt", "options", "changeDefaults", "_getDefaults", "_defaults", "args", "tokens", "callback", "_Parser", "_Renderer", "_TextRenderer", "_Lexer", "_Tokenizer", "_Hooks", "setOptions", "use", "walkTokens", "parseInline", "parse", "parser", "lexer"] +} diff --git a/frontend/node_modules/marked/man/marked.1 b/frontend/node_modules/marked/man/marked.1 new file mode 100644 index 0000000..566783b --- /dev/null +++ b/frontend/node_modules/marked/man/marked.1 @@ -0,0 +1,113 @@ +.TH "MARKED" "1" "June 2026" "18.0.4" +.SH "NAME" +\fBmarked\fR \- a javascript markdown parser +.SH SYNOPSIS +.P +\fBmarked\fP [\fB\-o\fP ] [\fB\-i\fP ] [\fB\-s\fP ] [\fB\-c\fP ] [\fB\-\-help\fP] [\fB\-\-version\fP] [\fB\-\-tokens\fP] [\fB\-\-no\-clobber\fP] [\fB\-\-pedantic\fP] [\fB\-\-gfm\fP] [\fB\-\-breaks\fP] [\fB\-\-no\-etc\.\.\.\fP] [\fB\-\-silent\fP] [filename] +.SH DESCRIPTION +.P +marked is a full\-featured javascript markdown parser, built for speed\. +.br +It also includes multiple GFM features\. +.SH EXAMPLES +.RS 2 +.nf +cat in\.md | marked > out\.html +.fi +.RE +.RS 2 +.nf +echo "hello *world*" | marked +.fi +.RE +.RS 2 +.nf +marked \-o out\.html \-i in\.md \-\-gfm +.fi +.RE +.RS 2 +.nf +marked \-\-output="hello world\.html" \-i in\.md \-\-no\-breaks +.fi +.RE +.SH OPTIONS + +.RS 1 +.IP \(bu 2 +\-o, \-\-output [output file] +.br +Specify file output\. If none is specified, write to stdout\. +.IP \(bu 2 +\-i, \-\-input [input file] +.br +Specify file input, otherwise use last argument as input file\. +.br +If no input file is specified, read from stdin\. +.IP \(bu 2 +\-s, \-\-string [markdown string] +.br +Specify string input instead of a file\. +.IP \(bu 2 +\-c, \-\-config [config file] +.br +Specify config file to use instead of the default \fB~/\.marked\.json\fP or \fB~/\.marked\.js\fP or \fB~/\.marked/index\.js\fP\|\. +.IP \(bu 2 +\-t, \-\-tokens +.br +Output a token list instead of html\. +.IP \(bu 2 +\-n, \-\-no\-clobber +.br +Do not overwrite \fBoutput\fP if it exists\. +.IP \(bu 2 +\-\-pedantic +.br +Conform to obscure parts of markdown\.pl as much as possible\. +.br +Don't fix original markdown bugs\. +.IP \(bu 2 +\-\-gfm +.br +Enable github flavored markdown\. +.IP \(bu 2 +\-\-breaks +.br +Enable GFM line breaks\. Only works with the gfm option\. +.IP \(bu 2 +\-\-no\-breaks, \-no\-etc\.\.\. +.br +The inverse of any of the marked options above\. +.IP \(bu 2 +\-\-silent +.br +Silence error output\. +.IP \(bu 2 +\-h, \-\-help +.br +Display help information\. + +.RE +.SH CONFIGURATION +.P +For configuring and running programmatically\. +.P +Example +.RS 2 +.nf +import { Marked } from 'marked'; +const marked = new Marked({ gfm: true }); +marked\.parse('*foo*'); +.fi +.RE +.SH BUGS +.P +Please report any bugs to https://github.com/markedjs/marked +.SH LICENSE +.P +Copyright (c) 2018+, MarkedJS\. (MIT License) +.br +Copyright (c) 2011\-2018, Christopher Jeffrey\. (MIT License) +.SH SEE ALSO +.P +markdown(1), nodejs(1) + diff --git a/frontend/node_modules/marked/man/marked.1.md b/frontend/node_modules/marked/man/marked.1.md new file mode 100644 index 0000000..0275511 --- /dev/null +++ b/frontend/node_modules/marked/man/marked.1.md @@ -0,0 +1,93 @@ +# marked(1) -- a javascript markdown parser + +## SYNOPSIS + +`marked` [`-o` ] [`-i` ] [`-s` ] [`-c` ] [`--help`] [`--version`] [`--tokens`] [`--no-clobber`] [`--pedantic`] [`--gfm`] [`--breaks`] [`--no-etc...`] [`--silent`] [filename] + +## DESCRIPTION + +marked is a full-featured javascript markdown parser, built for speed. +It also includes multiple GFM features. + +## EXAMPLES + +```sh +cat in.md | marked > out.html +``` + +```sh +echo "hello *world*" | marked +``` + +```sh +marked -o out.html -i in.md --gfm +``` + +```sh +marked --output="hello world.html" -i in.md --no-breaks +``` + +## OPTIONS + +* -o, --output [output file] +Specify file output. If none is specified, write to stdout. + +* -i, --input [input file] +Specify file input, otherwise use last argument as input file. +If no input file is specified, read from stdin. + +* -s, --string [markdown string] +Specify string input instead of a file. + +* -c, --config [config file] +Specify config file to use instead of the default `~/.marked.json` or `~/.marked.js` or `~/.marked/index.js`. + +* -t, --tokens +Output a token list instead of html. + +* -n, --no-clobber +Do not overwrite `output` if it exists. + +* --pedantic +Conform to obscure parts of markdown.pl as much as possible. +Don't fix original markdown bugs. + +* --gfm +Enable github flavored markdown. + +* --breaks +Enable GFM line breaks. Only works with the gfm option. + +* --no-breaks, -no-etc... +The inverse of any of the marked options above. + +* --silent +Silence error output. + +* -h, --help +Display help information. + +## CONFIGURATION + +For configuring and running programmatically. + +Example + +```js +import { Marked } from 'marked'; +const marked = new Marked({ gfm: true }); +marked.parse('*foo*'); +``` + +## BUGS + +Please report any bugs to . + +## LICENSE + +Copyright (c) 2018+, MarkedJS. (MIT License) +Copyright (c) 2011-2018, Christopher Jeffrey. (MIT License) + +## SEE ALSO + +markdown(1), nodejs(1) diff --git a/frontend/node_modules/marked/package.json b/frontend/node_modules/marked/package.json new file mode 100644 index 0000000..4527f22 --- /dev/null +++ b/frontend/node_modules/marked/package.json @@ -0,0 +1,103 @@ +{ + "name": "marked", + "description": "A markdown parser built for speed", + "author": "Christopher Jeffrey", + "version": "18.0.5", + "type": "module", + "main": "./lib/marked.esm.js", + "module": "./lib/marked.esm.js", + "browser": "./lib/marked.umd.js", + "types": "./lib/marked.d.ts", + "bin": { + "marked": "bin/marked.js" + }, + "man": "./man/marked.1", + "files": [ + "bin/", + "lib/", + "man/" + ], + "exports": { + ".": { + "types": "./lib/marked.d.ts", + "default": "./lib/marked.esm.js" + }, + "./bin/marked": "./bin/marked.js", + "./package.json": "./package.json" + }, + "publishConfig": { + "provenance": true + }, + "repository": { + "type": "git", + "url": "git://github.com/markedjs/marked.git" + }, + "homepage": "https://marked.js.org", + "bugs": { + "url": "http://github.com/markedjs/marked/issues" + }, + "license": "MIT", + "keywords": [ + "markdown", + "markup", + "html" + ], + "tags": [ + "markdown", + "markup", + "html" + ], + "devDependencies": { + "@arethetypeswrong/cli": "^0.18.3", + "@markedjs/eslint-config": "^1.0.14", + "@markedjs/testutils": "18.0.0-1", + "@semantic-release/commit-analyzer": "^13.0.1", + "@semantic-release/git": "^10.0.1", + "@semantic-release/github": "^12.0.8", + "@semantic-release/npm": "^13.1.5", + "@semantic-release/release-notes-generator": "^14.1.1", + "cheerio": "1.2.0", + "commonmark": "0.31.2", + "cross-env": "^10.1.0", + "dts-bundle-generator": "^9.5.1", + "esbuild": "^0.28.0", + "esbuild-plugin-umd-wrapper": "^3.0.0", + "eslint": "^10.4.1", + "highlight.js": "^11.11.1", + "markdown-it": "14.2.0", + "marked-highlight": "^2.2.4", + "marked-man": "^2.1.1", + "recheck": "^4.5.0", + "rimraf": "^6.1.3", + "semantic-release": "^25.0.3", + "titleize": "^4.0.0", + "tslib": "^2.8.1", + "typescript": "6.0.3" + }, + "scripts": { + "bench": "npm run build && node test/bench.js", + "build": "npm run build:esbuild && npm run build:types && npm run build:man", + "build:docs": "npm run build && node docs/build.js", + "build:esbuild": "node esbuild.config.js", + "build:man": "marked-man man/marked.1.md > man/marked.1", + "build:reset": "rimraf ./lib ./public", + "build:types": "tsc && dts-bundle-generator --export-referenced-types --project tsconfig.json -o lib/marked.d.ts src/marked.ts", + "lint": "eslint --fix", + "rules": "node test/rules.js", + "test": "npm run build:reset && npm run build:docs && npm run test:specs && npm run test:unit && npm run test:umd && npm run test:cjs && npm run test:types && npm run test:lint", + "test:cjs": "node test/cjs-test.cjs", + "test:lint": "eslint", + "test:only": "npm run build && npm run test:specs:only && npm run test:unit:only", + "test:redos": "node test/recheck.ts > vuln.js", + "test:specs:only": "node --test --test-only --test-reporter=spec test/run-spec-tests.js", + "test:specs": "node --test --test-reporter=spec test/run-spec-tests.js", + "test:types": "tsc --project tsconfig-type-test.json && attw -P --entrypoints . --profile esm-only", + "test:umd": "node test/umd-test.js", + "test:unit:only": "node --test --test-only --test-reporter=spec test/unit/*.test.js", + "test:unit": "node --test --test-reporter=spec test/unit/*.test.js", + "test:update": "node test/update-specs.js" + }, + "engines": { + "node": ">= 20" + } +} diff --git a/frontend/node_modules/nanoid/LICENSE b/frontend/node_modules/nanoid/LICENSE new file mode 100644 index 0000000..37f56aa --- /dev/null +++ b/frontend/node_modules/nanoid/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright 2017 Andrey Sitnik + +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/frontend/node_modules/nanoid/README.md b/frontend/node_modules/nanoid/README.md new file mode 100644 index 0000000..5124349 --- /dev/null +++ b/frontend/node_modules/nanoid/README.md @@ -0,0 +1,36 @@ +# Nano ID + +Nano ID logo by Anton Lovchikov + +**English** | [Русский](./README.ru.md) | [简体中文](./README.zh-CN.md) | [Bahasa Indonesia](./README.id-ID.md) + +A tiny, secure, URL-friendly, unique string ID generator for JavaScript. + +> “An amazing level of senseless perfectionism, +> which is simply impossible not to respect.” + +* **Small.** 130 bytes (minified and gzipped). No dependencies. + [Size Limit] controls the size. +* **Fast.** It is 2 times faster than UUID. +* **Safe.** It uses hardware random generator. Can be used in clusters. +* **Short IDs.** It uses a larger alphabet than UUID (`A-Za-z0-9_-`). + So ID size was reduced from 36 to 21 symbols. +* **Portable.** Nano ID was ported + to [20 programming languages](#other-programming-languages). + +```js +import { nanoid } from 'nanoid' +model.id = nanoid() //=> "V1StGXR8_Z5jdHi6B-myT" +``` + +Supports modern browsers, IE [with Babel], Node.js and React Native. + +[online tool]: https://gitpod.io/#https://github.com/ai/nanoid/ +[with Babel]: https://developer.epages.com/blog/coding/how-to-transpile-node-modules-with-babel-and-webpack-in-a-monorepo/ +[Size Limit]: https://github.com/ai/size-limit + +     + Sponsored by Evil Martians + diff --git a/frontend/node_modules/nanoid/async/index.browser.cjs b/frontend/node_modules/nanoid/async/index.browser.cjs new file mode 100644 index 0000000..9f8c3a3 --- /dev/null +++ b/frontend/node_modules/nanoid/async/index.browser.cjs @@ -0,0 +1,42 @@ +let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes)) + +let customAlphabet = (alphabet, defaultSize = 21) => { + let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1 + + + + let step = -~((1.6 * mask * defaultSize) / alphabet.length) + + return async (size = defaultSize) => { + let id = '' + while (true) { + let bytes = crypto.getRandomValues(new Uint8Array(step)) + let i = step | 0 + while (i--) { + id += alphabet[bytes[i] & mask] || '' + if (id.length === size) return id + } + } + } +} + +let nanoid = async (size = 21) => { + let id = '' + let bytes = crypto.getRandomValues(new Uint8Array((size |= 0))) + + while (size--) { + let byte = bytes[size] & 63 + if (byte < 36) { + id += byte.toString(36) + } else if (byte < 62) { + id += (byte - 26).toString(36).toUpperCase() + } else if (byte < 63) { + id += '_' + } else { + id += '-' + } + } + return id +} + +module.exports = { nanoid, customAlphabet, random } diff --git a/frontend/node_modules/nanoid/async/index.browser.js b/frontend/node_modules/nanoid/async/index.browser.js new file mode 100644 index 0000000..9e5da48 --- /dev/null +++ b/frontend/node_modules/nanoid/async/index.browser.js @@ -0,0 +1,42 @@ +let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes)) + +let customAlphabet = (alphabet, defaultSize = 21) => { + let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1 + + + + let step = -~((1.6 * mask * defaultSize) / alphabet.length) + + return async (size = defaultSize) => { + let id = '' + while (true) { + let bytes = crypto.getRandomValues(new Uint8Array(step)) + let i = step | 0 + while (i--) { + id += alphabet[bytes[i] & mask] || '' + if (id.length === size) return id + } + } + } +} + +let nanoid = async (size = 21) => { + let id = '' + let bytes = crypto.getRandomValues(new Uint8Array((size |= 0))) + + while (size--) { + let byte = bytes[size] & 63 + if (byte < 36) { + id += byte.toString(36) + } else if (byte < 62) { + id += (byte - 26).toString(36).toUpperCase() + } else if (byte < 63) { + id += '_' + } else { + id += '-' + } + } + return id +} + +export { nanoid, customAlphabet, random } diff --git a/frontend/node_modules/nanoid/async/index.cjs b/frontend/node_modules/nanoid/async/index.cjs new file mode 100644 index 0000000..d6db856 --- /dev/null +++ b/frontend/node_modules/nanoid/async/index.cjs @@ -0,0 +1,44 @@ +let crypto = require('crypto') + +let { urlAlphabet } = require('../url-alphabet/index.cjs') + +let random = bytes => + new Promise((resolve, reject) => { + crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => { + if (err) { + reject(err) + } else { + resolve(buf) + } + }) + }) + +let customAlphabet = (alphabet, defaultSize = 21) => { + let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1 + + + let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length) + + let tick = (id, size = defaultSize) => + random(step).then(bytes => { + let i = step + while (i--) { + id += alphabet[bytes[i] & mask] || '' + if (id.length >= size) return id + } + return tick(id, size) + }) + + return size => tick('', size) +} + +let nanoid = (size = 21) => + random((size |= 0)).then(bytes => { + let id = '' + while (size--) { + id += urlAlphabet[bytes[size] & 63] + } + return id + }) + +module.exports = { nanoid, customAlphabet, random } diff --git a/frontend/node_modules/nanoid/async/index.d.ts b/frontend/node_modules/nanoid/async/index.d.ts new file mode 100644 index 0000000..9e91965 --- /dev/null +++ b/frontend/node_modules/nanoid/async/index.d.ts @@ -0,0 +1,56 @@ +/** + * Generate secure URL-friendly unique ID. The non-blocking version. + * + * By default, the ID will have 21 symbols to have a collision probability + * similar to UUID v4. + * + * ```js + * import { nanoid } from 'nanoid/async' + * nanoid().then(id => { + * model.id = id + * }) + * ``` + * + * @param size Size of the ID. The default size is 21. + * @returns A promise with a random string. + */ +export function nanoid(size?: number): Promise + +/** + * A low-level function. + * Generate secure unique ID with custom alphabet. The non-blocking version. + * + * Alphabet must contain 256 symbols or less. Otherwise, the generator + * will not be secure. + * + * @param alphabet Alphabet used to generate the ID. + * @param defaultSize Size of the ID. The default size is 21. + * @returns A function that returns a promise with a random string. + * + * ```js + * import { customAlphabet } from 'nanoid/async' + * const nanoid = customAlphabet('0123456789абвгдеё', 5) + * nanoid().then(id => { + * model.id = id //=> "8ё56а" + * }) + * ``` + */ +export function customAlphabet( + alphabet: string, + defaultSize?: number +): (size?: number) => Promise + +/** + * Generate an array of random bytes collected from hardware noise. + * + * ```js + * import { random } from 'nanoid/async' + * random(5).then(bytes => { + * bytes //=> [10, 67, 212, 67, 89] + * }) + * ``` + * + * @param bytes Size of the array. + * @returns A promise with a random bytes array. + */ +export function random(bytes: number): Promise diff --git a/frontend/node_modules/nanoid/async/index.js b/frontend/node_modules/nanoid/async/index.js new file mode 100644 index 0000000..4df5919 --- /dev/null +++ b/frontend/node_modules/nanoid/async/index.js @@ -0,0 +1,44 @@ +import crypto from 'crypto' + +import { urlAlphabet } from '../url-alphabet/index.js' + +let random = bytes => + new Promise((resolve, reject) => { + crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => { + if (err) { + reject(err) + } else { + resolve(buf) + } + }) + }) + +let customAlphabet = (alphabet, defaultSize = 21) => { + let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1 + + + let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length) + + let tick = (id, size = defaultSize) => + random(step).then(bytes => { + let i = step + while (i--) { + id += alphabet[bytes[i] & mask] || '' + if (id.length >= size) return id + } + return tick(id, size) + }) + + return size => tick('', size) +} + +let nanoid = (size = 21) => + random((size |= 0)).then(bytes => { + let id = '' + while (size--) { + id += urlAlphabet[bytes[size] & 63] + } + return id + }) + +export { nanoid, customAlphabet, random } diff --git a/frontend/node_modules/nanoid/async/index.native.js b/frontend/node_modules/nanoid/async/index.native.js new file mode 100644 index 0000000..9579c12 --- /dev/null +++ b/frontend/node_modules/nanoid/async/index.native.js @@ -0,0 +1,35 @@ +import { getRandomBytesAsync } from 'expo-random' + +import { urlAlphabet } from '../url-alphabet/index.js' + +let random = getRandomBytesAsync + +let customAlphabet = (alphabet, defaultSize = 21) => { + let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1 + + + let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length) + + let tick = (id, size = defaultSize) => + random(step).then(bytes => { + let i = step + while (i--) { + id += alphabet[bytes[i] & mask] || '' + if (id.length >= size) return id + } + return tick(id, size) + }) + + return size => tick('', size) +} + +let nanoid = (size = 21) => + random((size |= 0)).then(bytes => { + let id = '' + while (size--) { + id += urlAlphabet[bytes[size] & 63] + } + return id + }) + +export { nanoid, customAlphabet, random } diff --git a/frontend/node_modules/nanoid/async/package.json b/frontend/node_modules/nanoid/async/package.json new file mode 100644 index 0000000..578cdb4 --- /dev/null +++ b/frontend/node_modules/nanoid/async/package.json @@ -0,0 +1,12 @@ +{ + "type": "module", + "main": "index.cjs", + "module": "index.js", + "react-native": { + "./index.js": "./index.native.js" + }, + "browser": { + "./index.js": "./index.browser.js", + "./index.cjs": "./index.browser.cjs" + } +} \ No newline at end of file diff --git a/frontend/node_modules/nanoid/bin/nanoid.cjs b/frontend/node_modules/nanoid/bin/nanoid.cjs new file mode 100755 index 0000000..c76db0f --- /dev/null +++ b/frontend/node_modules/nanoid/bin/nanoid.cjs @@ -0,0 +1,55 @@ +#!/usr/bin/env node + +let { nanoid, customAlphabet } = require('..') + +function print(msg) { + process.stdout.write(msg + '\n') +} + +function error(msg) { + process.stderr.write(msg + '\n') + process.exit(1) +} + +if (process.argv.includes('--help') || process.argv.includes('-h')) { + print(` + Usage + $ nanoid [options] + + Options + -s, --size Generated ID size + -a, --alphabet Alphabet to use + -h, --help Show this help + + Examples + $ nanoid --s 15 + S9sBF77U6sDB8Yg + + $ nanoid --size 10 --alphabet abc + bcabababca`) + process.exit() +} + +let alphabet, size +for (let i = 2; i < process.argv.length; i++) { + let arg = process.argv[i] + if (arg === '--size' || arg === '-s') { + size = Number(process.argv[i + 1]) + i += 1 + if (Number.isNaN(size) || size <= 0) { + error('Size must be positive integer') + } + } else if (arg === '--alphabet' || arg === '-a') { + alphabet = process.argv[i + 1] + i += 1 + } else { + error('Unknown argument ' + arg) + } +} + +if (alphabet) { + let customNanoid = customAlphabet(alphabet, size) + print(customNanoid()) +} else { + print(nanoid(size)) +} diff --git a/frontend/node_modules/nanoid/index.browser.cjs b/frontend/node_modules/nanoid/index.browser.cjs new file mode 100644 index 0000000..2b4b7b6 --- /dev/null +++ b/frontend/node_modules/nanoid/index.browser.cjs @@ -0,0 +1,44 @@ + +let { urlAlphabet } = require('./url-alphabet/index.cjs') + +let random = bytes => crypto.getRandomValues(new Uint8Array(bytes)) + +let customRandom = (alphabet, defaultSize, getRandom) => { + let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1 + + + + let step = -~((1.6 * mask * defaultSize) / alphabet.length) + + return (size = defaultSize) => { + let id = '' + while (true) { + let bytes = getRandom(step) + let j = step | 0 + while (j--) { + id += alphabet[bytes[j] & mask] || '' + if (id.length === size) return id + } + } + } +} + +let customAlphabet = (alphabet, size = 21) => + customRandom(alphabet, size, random) + +let nanoid = (size = 21) => + crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => { + byte &= 63 + if (byte < 36) { + id += byte.toString(36) + } else if (byte < 62) { + id += (byte - 26).toString(36).toUpperCase() + } else if (byte > 62) { + id += '-' + } else { + id += '_' + } + return id + }, '') + +module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random } diff --git a/frontend/node_modules/nanoid/index.browser.js b/frontend/node_modules/nanoid/index.browser.js new file mode 100644 index 0000000..db69b3a --- /dev/null +++ b/frontend/node_modules/nanoid/index.browser.js @@ -0,0 +1,44 @@ + +import { urlAlphabet } from './url-alphabet/index.js' + +let random = bytes => crypto.getRandomValues(new Uint8Array(bytes)) + +let customRandom = (alphabet, defaultSize, getRandom) => { + let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1 + + + + let step = -~((1.6 * mask * defaultSize) / alphabet.length) + + return (size = defaultSize) => { + let id = '' + while (true) { + let bytes = getRandom(step) + let j = step | 0 + while (j--) { + id += alphabet[bytes[j] & mask] || '' + if (id.length === size) return id + } + } + } +} + +let customAlphabet = (alphabet, size = 21) => + customRandom(alphabet, size, random) + +let nanoid = (size = 21) => + crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => { + byte &= 63 + if (byte < 36) { + id += byte.toString(36) + } else if (byte < 62) { + id += (byte - 26).toString(36).toUpperCase() + } else if (byte > 62) { + id += '-' + } else { + id += '_' + } + return id + }, '') + +export { nanoid, customAlphabet, customRandom, urlAlphabet, random } diff --git a/frontend/node_modules/nanoid/index.cjs b/frontend/node_modules/nanoid/index.cjs new file mode 100644 index 0000000..9d50c52 --- /dev/null +++ b/frontend/node_modules/nanoid/index.cjs @@ -0,0 +1,57 @@ +let crypto = require('crypto') + +let { urlAlphabet } = require('./url-alphabet/index.cjs') + +const POOL_SIZE_MULTIPLIER = 128 +let pool, poolOffset + +let fillPool = bytes => { + if (bytes < 0 || bytes > 1024) throw new RangeError('Wrong ID size') + if (!pool || pool.length < bytes) { + pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER) + crypto.randomFillSync(pool) + poolOffset = 0 + } else if (poolOffset + bytes > pool.length) { + crypto.randomFillSync(pool) + poolOffset = 0 + } + poolOffset += bytes +} + +let random = bytes => { + fillPool((bytes |= 0)) + return pool.subarray(poolOffset - bytes, poolOffset) +} + +let customRandom = (alphabet, defaultSize, getRandom) => { + let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1 + + + let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length) + + return (size = defaultSize) => { + let id = '' + while (true) { + let bytes = getRandom(step) + let i = step + while (i--) { + id += alphabet[bytes[i] & mask] || '' + if (id.length === size) return id + } + } + } +} + +let customAlphabet = (alphabet, size = 21) => + customRandom(alphabet, size, random) + +let nanoid = (size = 21) => { + fillPool((size |= 0)) + let id = '' + for (let i = poolOffset - size; i < poolOffset; i++) { + id += urlAlphabet[pool[i] & 63] + } + return id +} + +module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random } diff --git a/frontend/node_modules/nanoid/index.d.cts b/frontend/node_modules/nanoid/index.d.cts new file mode 100644 index 0000000..3e111a3 --- /dev/null +++ b/frontend/node_modules/nanoid/index.d.cts @@ -0,0 +1,91 @@ +/** + * Generate secure URL-friendly unique ID. + * + * By default, the ID will have 21 symbols to have a collision probability + * similar to UUID v4. + * + * ```js + * import { nanoid } from 'nanoid' + * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL" + * ``` + * + * @param size Size of the ID. The default size is 21. + * @returns A random string. + */ +export function nanoid(size?: number): string + +/** + * Generate secure unique ID with custom alphabet. + * + * Alphabet must contain 256 symbols or less. Otherwise, the generator + * will not be secure. + * + * @param alphabet Alphabet used to generate the ID. + * @param defaultSize Size of the ID. The default size is 21. + * @returns A random string generator. + * + * ```js + * const { customAlphabet } = require('nanoid') + * const nanoid = customAlphabet('0123456789абвгдеё', 5) + * nanoid() //=> "8ё56а" + * ``` + */ +export function customAlphabet( + alphabet: string, + defaultSize?: number +): (size?: number) => string + +/** + * Generate unique ID with custom random generator and alphabet. + * + * Alphabet must contain 256 symbols or less. Otherwise, the generator + * will not be secure. + * + * ```js + * import { customRandom } from 'nanoid/format' + * + * const nanoid = customRandom('abcdef', 5, size => { + * const random = [] + * for (let i = 0; i < size; i++) { + * random.push(randomByte()) + * } + * return random + * }) + * + * nanoid() //=> "fbaef" + * ``` + * + * @param alphabet Alphabet used to generate a random string. + * @param size Size of the random string. + * @param random A random bytes generator. + * @returns A random string generator. + */ +export function customRandom( + alphabet: string, + size: number, + random: (bytes: number) => Uint8Array +): () => string + +/** + * URL safe symbols. + * + * ```js + * import { urlAlphabet } from 'nanoid' + * const nanoid = customAlphabet(urlAlphabet, 10) + * nanoid() //=> "Uakgb_J5m9" + * ``` + */ +export const urlAlphabet: string + +/** + * Generate an array of random bytes collected from hardware noise. + * + * ```js + * import { customRandom, random } from 'nanoid' + * const nanoid = customRandom("abcdef", 5, random) + * ``` + * + * @param bytes Size of the array. + * @returns An array of random bytes. + */ +export function random(bytes: number): Uint8Array diff --git a/frontend/node_modules/nanoid/index.d.ts b/frontend/node_modules/nanoid/index.d.ts new file mode 100644 index 0000000..3e111a3 --- /dev/null +++ b/frontend/node_modules/nanoid/index.d.ts @@ -0,0 +1,91 @@ +/** + * Generate secure URL-friendly unique ID. + * + * By default, the ID will have 21 symbols to have a collision probability + * similar to UUID v4. + * + * ```js + * import { nanoid } from 'nanoid' + * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL" + * ``` + * + * @param size Size of the ID. The default size is 21. + * @returns A random string. + */ +export function nanoid(size?: number): string + +/** + * Generate secure unique ID with custom alphabet. + * + * Alphabet must contain 256 symbols or less. Otherwise, the generator + * will not be secure. + * + * @param alphabet Alphabet used to generate the ID. + * @param defaultSize Size of the ID. The default size is 21. + * @returns A random string generator. + * + * ```js + * const { customAlphabet } = require('nanoid') + * const nanoid = customAlphabet('0123456789абвгдеё', 5) + * nanoid() //=> "8ё56а" + * ``` + */ +export function customAlphabet( + alphabet: string, + defaultSize?: number +): (size?: number) => string + +/** + * Generate unique ID with custom random generator and alphabet. + * + * Alphabet must contain 256 symbols or less. Otherwise, the generator + * will not be secure. + * + * ```js + * import { customRandom } from 'nanoid/format' + * + * const nanoid = customRandom('abcdef', 5, size => { + * const random = [] + * for (let i = 0; i < size; i++) { + * random.push(randomByte()) + * } + * return random + * }) + * + * nanoid() //=> "fbaef" + * ``` + * + * @param alphabet Alphabet used to generate a random string. + * @param size Size of the random string. + * @param random A random bytes generator. + * @returns A random string generator. + */ +export function customRandom( + alphabet: string, + size: number, + random: (bytes: number) => Uint8Array +): () => string + +/** + * URL safe symbols. + * + * ```js + * import { urlAlphabet } from 'nanoid' + * const nanoid = customAlphabet(urlAlphabet, 10) + * nanoid() //=> "Uakgb_J5m9" + * ``` + */ +export const urlAlphabet: string + +/** + * Generate an array of random bytes collected from hardware noise. + * + * ```js + * import { customRandom, random } from 'nanoid' + * const nanoid = customRandom("abcdef", 5, random) + * ``` + * + * @param bytes Size of the array. + * @returns An array of random bytes. + */ +export function random(bytes: number): Uint8Array diff --git a/frontend/node_modules/nanoid/index.js b/frontend/node_modules/nanoid/index.js new file mode 100644 index 0000000..c5d67b7 --- /dev/null +++ b/frontend/node_modules/nanoid/index.js @@ -0,0 +1,62 @@ +import crypto from 'crypto' + +import { urlAlphabet } from './url-alphabet/index.js' + +const POOL_SIZE_MULTIPLIER = 128 +let pool, poolOffset + +let fillPool = bytes => { + if (bytes < 0) throw new RangeError('Wrong ID size') + try { + if (!pool || pool.length < bytes) { + pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER) + crypto.randomFillSync(pool) + poolOffset = 0 + } else if (poolOffset + bytes > pool.length) { + crypto.randomFillSync(pool) + poolOffset = 0 + } + } catch (e) { + pool = undefined + throw e + } + poolOffset += bytes +} + +let random = bytes => { + fillPool((bytes |= 0)) + return pool.subarray(poolOffset - bytes, poolOffset) +} + +let customRandom = (alphabet, defaultSize, getRandom) => { + let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1 + + + let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length) + + return (size = defaultSize) => { + let id = '' + while (true) { + let bytes = getRandom(step) + let i = step + while (i--) { + id += alphabet[bytes[i] & mask] || '' + if (id.length === size) return id + } + } + } +} + +let customAlphabet = (alphabet, size = 21) => + customRandom(alphabet, size, random) + +let nanoid = (size = 21) => { + fillPool((size |= 0)) + let id = '' + for (let i = poolOffset - size; i < poolOffset; i++) { + id += urlAlphabet[pool[i] & 63] + } + return id +} + +export { nanoid, customAlphabet, customRandom, urlAlphabet, random } diff --git a/frontend/node_modules/nanoid/nanoid.js b/frontend/node_modules/nanoid/nanoid.js new file mode 100644 index 0000000..ec242ea --- /dev/null +++ b/frontend/node_modules/nanoid/nanoid.js @@ -0,0 +1 @@ +export let nanoid=(t=21)=>crypto.getRandomValues(new Uint8Array(t)).reduce(((t,e)=>t+=(e&=63)<36?e.toString(36):e<62?(e-26).toString(36).toUpperCase():e<63?"_":"-"),""); \ No newline at end of file diff --git a/frontend/node_modules/nanoid/non-secure/index.cjs b/frontend/node_modules/nanoid/non-secure/index.cjs new file mode 100644 index 0000000..b32f42b --- /dev/null +++ b/frontend/node_modules/nanoid/non-secure/index.cjs @@ -0,0 +1,24 @@ +let urlAlphabet = + 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict' + +let customAlphabet = (alphabet, defaultSize = 21) => { + return (size = defaultSize) => { + let id = '' + let i = size | 0 + while (i--) { + id += alphabet[(Math.random() * alphabet.length) | 0] + } + return id + } +} + +let nanoid = (size = 21) => { + let id = '' + let i = size | 0 + while (i--) { + id += urlAlphabet[(Math.random() * 64) | 0] + } + return id +} + +module.exports = { nanoid, customAlphabet } diff --git a/frontend/node_modules/nanoid/non-secure/index.d.ts b/frontend/node_modules/nanoid/non-secure/index.d.ts new file mode 100644 index 0000000..4965322 --- /dev/null +++ b/frontend/node_modules/nanoid/non-secure/index.d.ts @@ -0,0 +1,33 @@ +/** + * Generate URL-friendly unique ID. This method uses the non-secure + * predictable random generator with bigger collision probability. + * + * ```js + * import { nanoid } from 'nanoid/non-secure' + * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL" + * ``` + * + * @param size Size of the ID. The default size is 21. + * @returns A random string. + */ +export function nanoid(size?: number): string + +/** + * Generate a unique ID based on a custom alphabet. + * This method uses the non-secure predictable random generator + * with bigger collision probability. + * + * @param alphabet Alphabet used to generate the ID. + * @param defaultSize Size of the ID. The default size is 21. + * @returns A random string generator. + * + * ```js + * import { customAlphabet } from 'nanoid/non-secure' + * const nanoid = customAlphabet('0123456789абвгдеё', 5) + * model.id = //=> "8ё56а" + * ``` + */ +export function customAlphabet( + alphabet: string, + defaultSize?: number +): (size?: number) => string diff --git a/frontend/node_modules/nanoid/non-secure/index.js b/frontend/node_modules/nanoid/non-secure/index.js new file mode 100644 index 0000000..49b12c8 --- /dev/null +++ b/frontend/node_modules/nanoid/non-secure/index.js @@ -0,0 +1,24 @@ +let urlAlphabet = + 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict' + +let customAlphabet = (alphabet, defaultSize = 21) => { + return (size = defaultSize) => { + let id = '' + let i = size | 0 + while (i--) { + id += alphabet[(Math.random() * alphabet.length) | 0] + } + return id + } +} + +let nanoid = (size = 21) => { + let id = '' + let i = size | 0 + while (i--) { + id += urlAlphabet[(Math.random() * 64) | 0] + } + return id +} + +export { nanoid, customAlphabet } diff --git a/frontend/node_modules/nanoid/non-secure/package.json b/frontend/node_modules/nanoid/non-secure/package.json new file mode 100644 index 0000000..9930d6a --- /dev/null +++ b/frontend/node_modules/nanoid/non-secure/package.json @@ -0,0 +1,6 @@ +{ + "type": "module", + "main": "index.cjs", + "module": "index.js", + "react-native": "index.js" +} \ No newline at end of file diff --git a/frontend/node_modules/nanoid/package.json b/frontend/node_modules/nanoid/package.json new file mode 100644 index 0000000..b76bde9 --- /dev/null +++ b/frontend/node_modules/nanoid/package.json @@ -0,0 +1,89 @@ +{ + "name": "nanoid", + "version": "3.3.15", + "description": "A tiny (116 bytes), secure URL-friendly unique string ID generator", + "keywords": [ + "uuid", + "random", + "id", + "url" + ], + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + }, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "author": "Andrey Sitnik ", + "license": "MIT", + "repository": "ai/nanoid", + "browser": { + "./index.js": "./index.browser.js", + "./async/index.js": "./async/index.browser.js", + "./async/index.cjs": "./async/index.browser.cjs", + "./index.cjs": "./index.browser.cjs" + }, + "react-native": "index.js", + "bin": "./bin/nanoid.cjs", + "sideEffects": false, + "types": "./index.d.ts", + "type": "module", + "main": "index.cjs", + "module": "index.js", + "exports": { + ".": { + "react-native": "./index.browser.js", + "browser": "./index.browser.js", + "require": { + "types": "./index.d.cts", + "default": "./index.cjs" + }, + "import": { + "types": "./index.d.ts", + "default": "./index.js" + }, + "default": "./index.js" + }, + "./package.json": "./package.json", + "./async/package.json": "./async/package.json", + "./async": { + "browser": "./async/index.browser.js", + "require": { + "types": "./index.d.cts", + "default": "./async/index.cjs" + }, + "import": { + "types": "./index.d.ts", + "default": "./async/index.js" + }, + "default": "./async/index.js" + }, + "./non-secure/package.json": "./non-secure/package.json", + "./non-secure": { + "require": { + "types": "./index.d.cts", + "default": "./non-secure/index.cjs" + }, + "import": { + "types": "./index.d.ts", + "default": "./non-secure/index.js" + }, + "default": "./non-secure/index.js" + }, + "./url-alphabet/package.json": "./url-alphabet/package.json", + "./url-alphabet": { + "require": { + "types": "./index.d.cts", + "default": "./url-alphabet/index.cjs" + }, + "import": { + "types": "./index.d.ts", + "default": "./url-alphabet/index.js" + }, + "default": "./url-alphabet/index.js" + } + } +} diff --git a/frontend/node_modules/nanoid/url-alphabet/index.cjs b/frontend/node_modules/nanoid/url-alphabet/index.cjs new file mode 100644 index 0000000..9021f0b --- /dev/null +++ b/frontend/node_modules/nanoid/url-alphabet/index.cjs @@ -0,0 +1,4 @@ +let urlAlphabet = + 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict' + +module.exports = { urlAlphabet } diff --git a/frontend/node_modules/nanoid/url-alphabet/index.js b/frontend/node_modules/nanoid/url-alphabet/index.js new file mode 100644 index 0000000..f995c4f --- /dev/null +++ b/frontend/node_modules/nanoid/url-alphabet/index.js @@ -0,0 +1,4 @@ +let urlAlphabet = + 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict' + +export { urlAlphabet } diff --git a/frontend/node_modules/nanoid/url-alphabet/package.json b/frontend/node_modules/nanoid/url-alphabet/package.json new file mode 100644 index 0000000..9930d6a --- /dev/null +++ b/frontend/node_modules/nanoid/url-alphabet/package.json @@ -0,0 +1,6 @@ +{ + "type": "module", + "main": "index.cjs", + "module": "index.js", + "react-native": "index.js" +} \ No newline at end of file diff --git a/frontend/node_modules/picocolors/LICENSE b/frontend/node_modules/picocolors/LICENSE new file mode 100644 index 0000000..46c9b95 --- /dev/null +++ b/frontend/node_modules/picocolors/LICENSE @@ -0,0 +1,15 @@ +ISC License + +Copyright (c) 2021-2024 Oleksii Raspopov, Kostiantyn Denysov, Anton Verinov + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/frontend/node_modules/picocolors/README.md b/frontend/node_modules/picocolors/README.md new file mode 100644 index 0000000..8e47aa8 --- /dev/null +++ b/frontend/node_modules/picocolors/README.md @@ -0,0 +1,21 @@ +# picocolors + +The tiniest and the fastest library for terminal output formatting with ANSI colors. + +```javascript +import pc from "picocolors" + +console.log( + pc.green(`How are ${pc.italic(`you`)} doing?`) +) +``` + +- **No dependencies.** +- **14 times** smaller and **2 times** faster than chalk. +- Used by popular tools like PostCSS, SVGO, Stylelint, and Browserslist. +- Node.js v6+ & browsers support. Support for both CJS and ESM projects. +- TypeScript type declarations included. +- [`NO_COLOR`](https://no-color.org/) friendly. + +## Docs +Read **[full docs](https://github.com/alexeyraspopov/picocolors#readme)** on GitHub. diff --git a/frontend/node_modules/picocolors/package.json b/frontend/node_modules/picocolors/package.json new file mode 100644 index 0000000..372d4b6 --- /dev/null +++ b/frontend/node_modules/picocolors/package.json @@ -0,0 +1,25 @@ +{ + "name": "picocolors", + "version": "1.1.1", + "main": "./picocolors.js", + "types": "./picocolors.d.ts", + "browser": { + "./picocolors.js": "./picocolors.browser.js" + }, + "sideEffects": false, + "description": "The tiniest and the fastest library for terminal output formatting with ANSI colors", + "files": [ + "picocolors.*", + "types.d.ts" + ], + "keywords": [ + "terminal", + "colors", + "formatting", + "cli", + "console" + ], + "author": "Alexey Raspopov", + "repository": "alexeyraspopov/picocolors", + "license": "ISC" +} diff --git a/frontend/node_modules/picocolors/picocolors.browser.js b/frontend/node_modules/picocolors/picocolors.browser.js new file mode 100644 index 0000000..9dcf637 --- /dev/null +++ b/frontend/node_modules/picocolors/picocolors.browser.js @@ -0,0 +1,4 @@ +var x=String; +var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}}; +module.exports=create(); +module.exports.createColors = create; diff --git a/frontend/node_modules/picocolors/picocolors.d.ts b/frontend/node_modules/picocolors/picocolors.d.ts new file mode 100644 index 0000000..94e146a --- /dev/null +++ b/frontend/node_modules/picocolors/picocolors.d.ts @@ -0,0 +1,5 @@ +import { Colors } from "./types" + +declare const picocolors: Colors & { createColors: (enabled?: boolean) => Colors } + +export = picocolors diff --git a/frontend/node_modules/picocolors/picocolors.js b/frontend/node_modules/picocolors/picocolors.js new file mode 100644 index 0000000..e32df85 --- /dev/null +++ b/frontend/node_modules/picocolors/picocolors.js @@ -0,0 +1,75 @@ +let p = process || {}, argv = p.argv || [], env = p.env || {} +let isColorSupported = + !(!!env.NO_COLOR || argv.includes("--no-color")) && + (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI) + +let formatter = (open, close, replace = open) => + input => { + let string = "" + input, index = string.indexOf(close, open.length) + return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close + } + +let replaceClose = (string, close, replace, index) => { + let result = "", cursor = 0 + do { + result += string.substring(cursor, index) + replace + cursor = index + close.length + index = string.indexOf(close, cursor) + } while (~index) + return result + string.substring(cursor) +} + +let createColors = (enabled = isColorSupported) => { + let f = enabled ? formatter : () => String + return { + isColorSupported: enabled, + reset: f("\x1b[0m", "\x1b[0m"), + bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"), + dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"), + italic: f("\x1b[3m", "\x1b[23m"), + underline: f("\x1b[4m", "\x1b[24m"), + inverse: f("\x1b[7m", "\x1b[27m"), + hidden: f("\x1b[8m", "\x1b[28m"), + strikethrough: f("\x1b[9m", "\x1b[29m"), + + black: f("\x1b[30m", "\x1b[39m"), + red: f("\x1b[31m", "\x1b[39m"), + green: f("\x1b[32m", "\x1b[39m"), + yellow: f("\x1b[33m", "\x1b[39m"), + blue: f("\x1b[34m", "\x1b[39m"), + magenta: f("\x1b[35m", "\x1b[39m"), + cyan: f("\x1b[36m", "\x1b[39m"), + white: f("\x1b[37m", "\x1b[39m"), + gray: f("\x1b[90m", "\x1b[39m"), + + bgBlack: f("\x1b[40m", "\x1b[49m"), + bgRed: f("\x1b[41m", "\x1b[49m"), + bgGreen: f("\x1b[42m", "\x1b[49m"), + bgYellow: f("\x1b[43m", "\x1b[49m"), + bgBlue: f("\x1b[44m", "\x1b[49m"), + bgMagenta: f("\x1b[45m", "\x1b[49m"), + bgCyan: f("\x1b[46m", "\x1b[49m"), + bgWhite: f("\x1b[47m", "\x1b[49m"), + + blackBright: f("\x1b[90m", "\x1b[39m"), + redBright: f("\x1b[91m", "\x1b[39m"), + greenBright: f("\x1b[92m", "\x1b[39m"), + yellowBright: f("\x1b[93m", "\x1b[39m"), + blueBright: f("\x1b[94m", "\x1b[39m"), + magentaBright: f("\x1b[95m", "\x1b[39m"), + cyanBright: f("\x1b[96m", "\x1b[39m"), + whiteBright: f("\x1b[97m", "\x1b[39m"), + + bgBlackBright: f("\x1b[100m", "\x1b[49m"), + bgRedBright: f("\x1b[101m", "\x1b[49m"), + bgGreenBright: f("\x1b[102m", "\x1b[49m"), + bgYellowBright: f("\x1b[103m", "\x1b[49m"), + bgBlueBright: f("\x1b[104m", "\x1b[49m"), + bgMagentaBright: f("\x1b[105m", "\x1b[49m"), + bgCyanBright: f("\x1b[106m", "\x1b[49m"), + bgWhiteBright: f("\x1b[107m", "\x1b[49m"), + } +} + +module.exports = createColors() +module.exports.createColors = createColors diff --git a/frontend/node_modules/picocolors/types.d.ts b/frontend/node_modules/picocolors/types.d.ts new file mode 100644 index 0000000..cd1aec4 --- /dev/null +++ b/frontend/node_modules/picocolors/types.d.ts @@ -0,0 +1,51 @@ +export type Formatter = (input: string | number | null | undefined) => string + +export interface Colors { + isColorSupported: boolean + + reset: Formatter + bold: Formatter + dim: Formatter + italic: Formatter + underline: Formatter + inverse: Formatter + hidden: Formatter + strikethrough: Formatter + + black: Formatter + red: Formatter + green: Formatter + yellow: Formatter + blue: Formatter + magenta: Formatter + cyan: Formatter + white: Formatter + gray: Formatter + + bgBlack: Formatter + bgRed: Formatter + bgGreen: Formatter + bgYellow: Formatter + bgBlue: Formatter + bgMagenta: Formatter + bgCyan: Formatter + bgWhite: Formatter + + blackBright: Formatter + redBright: Formatter + greenBright: Formatter + yellowBright: Formatter + blueBright: Formatter + magentaBright: Formatter + cyanBright: Formatter + whiteBright: Formatter + + bgBlackBright: Formatter + bgRedBright: Formatter + bgGreenBright: Formatter + bgYellowBright: Formatter + bgBlueBright: Formatter + bgMagentaBright: Formatter + bgCyanBright: Formatter + bgWhiteBright: Formatter +} diff --git a/frontend/node_modules/picomatch/LICENSE b/frontend/node_modules/picomatch/LICENSE new file mode 100644 index 0000000..3608dca --- /dev/null +++ b/frontend/node_modules/picomatch/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2017-present, Jon Schlinkert. + +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/frontend/node_modules/picomatch/README.md b/frontend/node_modules/picomatch/README.md new file mode 100644 index 0000000..a480c74 --- /dev/null +++ b/frontend/node_modules/picomatch/README.md @@ -0,0 +1,743 @@ +

    Picomatch

    + +

    + +version + + +test status + + +coverage status + + +downloads + +

    + +
    +
    + +

    +Blazing fast and accurate glob matcher written in JavaScript.
    +No dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions. +

    + +
    +
    + +## Why picomatch? + +* **Lightweight** - No dependencies +* **Minimal** - Tiny API surface. Main export is a function that takes a glob pattern and returns a matcher function. +* **Fast** - Loads in about 2ms (that's several times faster than a [single frame of a HD movie](http://www.endmemo.com/sconvert/framespersecondframespermillisecond.php) at 60fps) +* **Performant** - Use the returned matcher function to speed up repeat matching (like when watching files) +* **Accurate matching** - Using wildcards (`*` and `?`), globstars (`**`) for nested directories, [advanced globbing](#advanced-globbing) with extglobs, braces, and POSIX brackets, and support for escaping special characters with `\` or quotes. +* **Well tested** - Thousands of unit tests + +See the [library comparison](#library-comparisons) to other libraries. + +
    +
    + +## Table of Contents + +
    Click to expand + +- [Install](#install) +- [Usage](#usage) +- [API](#api) + * [picomatch](#picomatch) + * [.test](#test) + * [.matchBase](#matchbase) + * [.isMatch](#ismatch) + * [.parse](#parse) + * [.scan](#scan) + * [.compileRe](#compilere) + * [.makeRe](#makere) + * [.toRegex](#toregex) +- [Options](#options) + * [Picomatch options](#picomatch-options) + * [Scan Options](#scan-options) + * [Options Examples](#options-examples) +- [Globbing features](#globbing-features) + * [Basic globbing](#basic-globbing) + * [Advanced globbing](#advanced-globbing) + * [Braces](#braces) + * [Matching special characters as literals](#matching-special-characters-as-literals) +- [Library Comparisons](#library-comparisons) +- [Benchmarks](#benchmarks) +- [Philosophies](#philosophies) +- [About](#about) + * [Author](#author) + * [License](#license) + +_(TOC generated by [verb](https://github.com/verbose/verb) using [markdown-toc](https://github.com/jonschlinkert/markdown-toc))_ + +
    + +
    +
    + +## Install + +Install with [npm](https://www.npmjs.com/): + +```sh +npm install --save picomatch +``` + +
    + +## Usage + +The main export is a function that takes a glob pattern and an options object and returns a function for matching strings. + +```js +const pm = require('picomatch'); +const isMatch = pm('*.js'); + +console.log(isMatch('abcd')); //=> false +console.log(isMatch('a.js')); //=> true +console.log(isMatch('a.md')); //=> false +console.log(isMatch('a/b.js')); //=> false +``` + +
    + +## API + +### [picomatch](lib/picomatch.js#L43) + +Creates a matcher function from one or more glob patterns. The returned function takes a string to match as its first argument, and returns true if the string is a match. The returned matcher function also takes a boolean as the second argument that, when true, returns an object with additional information. + +**Params** + +* `globs` **{String|Array}**: One or more glob patterns. +* `options` **{Object=}** +* `returns` **{Function=}**: Returns a matcher function. + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch(glob[, options]); + +const isMatch = picomatch('*.!(*a)'); +console.log(isMatch('a.a')); //=> false +console.log(isMatch('a.b')); //=> true + +// For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection. +const picomatch = require('picomatch/posix'); +// the same API, defaulting to posix paths +const isMatch = picomatch('a/*'); +console.log(isMatch('a\\b')); //=> false +console.log(isMatch('a/b')); //=> true + +// you can still configure the matcher function to accept windows paths +const isMatch = picomatch('a/*', { options: windows }); +console.log(isMatch('a\\b')); //=> true +console.log(isMatch('a/b')); //=> true +``` + +### [.test](lib/picomatch.js#L128) + +Test `input` with the given `regex`. This is used by the main `picomatch()` function to test the input string. + +**Params** + +* `input` **{String}**: String to test. +* `regex` **{RegExp}** +* `returns` **{Object}**: Returns an object with matching info. + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.test(input, regex[, options]); + +console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/)); +// { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' } +``` + +### [.matchBase](lib/picomatch.js#L172) + +Match the basename of a filepath. + +**Params** + +* `input` **{String}**: String to test. +* `glob` **{RegExp|String}**: Glob pattern or regex created by [.makeRe](#makeRe). +* `returns` **{Boolean}** + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.matchBase(input, glob[, options]); +console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true +``` + +### [.isMatch](lib/picomatch.js#L194) + +Returns true if **any** of the given glob `patterns` match the specified `string`. + +**Params** + +* **{String|Array}**: str The string to test. +* **{String|Array}**: patterns One or more glob patterns to use for matching. +* **{Object}**: See available [options](#options). +* `returns` **{Boolean}**: Returns true if any patterns match `str` + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.isMatch(string, patterns[, options]); + +console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true +console.log(picomatch.isMatch('a.a', 'b.*')); //=> false +``` + +### [.parse](lib/picomatch.js#L210) + +Parse a glob pattern to create the source string for a regular expression. + +**Params** + +* `pattern` **{String}** +* `options` **{Object}** +* `returns` **{Object}**: Returns an object with useful properties and output to be used as a regex source string. + +**Example** + +```js +const picomatch = require('picomatch'); +const result = picomatch.parse(pattern[, options]); +``` + +### [.scan](lib/picomatch.js#L242) + +Scan a glob pattern to separate the pattern into segments. + +**Params** + +* `input` **{String}**: Glob pattern to scan. +* `options` **{Object}** +* `returns` **{Object}**: Returns an object with + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.scan(input[, options]); + +const result = picomatch.scan('!./foo/*.js'); +console.log(result); +{ prefix: '!./', + input: '!./foo/*.js', + start: 3, + base: 'foo', + glob: '*.js', + isBrace: false, + isBracket: false, + isGlob: true, + isExtglob: false, + isGlobstar: false, + negated: true } +``` + +### [.compileRe](lib/picomatch.js#L264) + +Compile a regular expression from the `state` object returned by the [parse()](#parse) method. + +**Params** + +* `state` **{Object}** +* `options` **{Object}** +* `returnOutput` **{Boolean}**: Intended for implementors, this argument allows you to return the raw output from the parser. +* `returnState` **{Boolean}**: Adds the state to a `state` property on the returned regex. Useful for implementors and debugging. +* `returns` **{RegExp}** + +**Example** + +```js +const picomatch = require('picomatch'); +const state = picomatch.parse('*.js'); +// picomatch.compileRe(state[, options]); + +console.log(picomatch.compileRe(state)); +//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ +``` + +### [.makeRe](lib/picomatch.js#L305) + +Create a regular expression from a parsed glob pattern. + +**Params** + +* `state` **{String}**: The object returned from the `.parse` method. +* `options` **{Object}** +* `returnOutput` **{Boolean}**: Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result. +* `returnState` **{Boolean}**: Implementors may use this argument to return the state from the parsed glob with the returned regular expression. +* `returns` **{RegExp}**: Returns a regex created from the given pattern. + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.makeRe(state[, options]); + +const result = picomatch.makeRe('*.js'); +console.log(result); +//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ +``` + +### [.toRegex](lib/picomatch.js#L340) + +Create a regular expression from the given regex source string. + +**Params** + +* `source` **{String}**: Regular expression source string. +* `options` **{Object}** +* `returns` **{RegExp}** + +**Example** + +```js +const picomatch = require('picomatch'); +// picomatch.toRegex(source[, options]); + +const { output } = picomatch.parse('*.js'); +console.log(picomatch.toRegex(output)); +//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ +``` + +
    + +## Options + +### Picomatch options + +The following options may be used with the main `picomatch()` function or any of the methods on the picomatch API. + +| **Option** | **Type** | **Default value** | **Description** | +| --- | --- | --- | --- | +| `basename` | `boolean` | `false` | If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. | +| `bash` | `boolean` | `false` | Follow bash matching rules more strictly - disallows backslashes as escape characters, and treats single stars as globstars (`**`). | +| `capture` | `boolean` | `undefined` | Return regex matches in supporting methods. | +| `contains` | `boolean` | `undefined` | Allows glob to match any part of the given string(s). | +| `debug` | `boolean` | `undefined` | Debug regular expressions when an error is thrown. | +| `dot` | `boolean` | `false` | Enable dotfile matching. By default, dotfiles are ignored unless a `.` is explicitly defined in the pattern, or `options.dot` is true | +| `expandRange` | `function` | `undefined` | Custom function for expanding ranges in brace patterns, such as `{a..z}`. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. | +| `fastpaths` | `boolean` | `true` | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to `false`. | +| `flags` | `string` | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. | +| [format](#optionsformat) | `function` | `undefined` | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. | +| `ignore` | `array\|string` | `undefined` | One or more glob patterns for excluding strings that should not be matched from the result. | +| `keepQuotes` | `boolean` | `false` | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes. | +| `literalBrackets` | `boolean` | `undefined` | When `true`, brackets in the glob pattern will be escaped so that only literal brackets will be matched. | +| `matchBase` | `boolean` | `false` | Alias for `basename` | +| `maxLength` | `number` | `65536` | Limit the max length of the input string. An error is thrown if the input string is longer than this value. | +| `maxExtglobRecursion` | `number\|boolean` | `0` | Limit nested quantified extglobs and other risky repeated extglob forms. When the limit is exceeded, the extglob is treated as a literal string instead of being compiled to regex. Set to `false` to disable this safeguard. | +| `nobrace` | `boolean` | `false` | Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters. | +| `nobracket` | `boolean` | `undefined` | Disable matching with regex brackets. | +| `nocase` | `boolean` | `false` | Make matching case-insensitive. Equivalent to the regex `i` flag. Note that this option is overridden by the `flags` option. | +| `noext` | `boolean` | `false` | Alias for `noextglob` | +| `noextglob` | `boolean` | `false` | Disable support for matching with extglobs (like `+(a\|b)`) | +| `noglobstar` | `boolean` | `false` | Disable support for matching nested directories with globstars (`**`) | +| `nonegate` | `boolean` | `false` | Disable support for negating with leading `!` | +| [onIgnore](#optionsonIgnore) | `function` | `undefined` | Function to be called on ignored items. | +| [onMatch](#optionsonMatch) | `function` | `undefined` | Function to be called on matched items. | +| [onResult](#optionsonResult) | `function` | `undefined` | Function to be called on all items, regardless of whether or not they are matched or ignored. | +| `posix` | `boolean` | `false` | Support POSIX character classes ("posix brackets"). | +| `prepend` | `boolean` | `undefined` | String to prepend to the generated regex used for matching. | +| `regex` | `boolean` | `false` | Use regular expression rules for `+` (instead of matching literal `+`), and for stars that follow closing parentheses or brackets (as in `)*` and `]*`). | +| `strictBrackets` | `boolean` | `undefined` | Throw an error if brackets, braces, or parens are imbalanced. | +| `strictSlashes` | `boolean` | `undefined` | When true, picomatch won't match trailing slashes with single stars. | +| `unescape` | `boolean` | `undefined` | Remove backslashes preceding escaped characters in the glob pattern. By default, backslashes are retained. | +| `windows` | `boolean` | `false` | Also accept backslashes as the path separator. | + +### Scan Options + +In addition to the main [picomatch options](#picomatch-options), the following options may also be used with the [.scan](#scan) method. + +| **Option** | **Type** | **Default value** | **Description** | +| --- | --- | --- | --- | +| `tokens` | `boolean` | `false` | When `true`, the returned object will include an array of tokens (objects), representing each path "segment" in the scanned glob pattern | +| `parts` | `boolean` | `false` | When `true`, the returned object will include an array of strings representing each path "segment" in the scanned glob pattern. This is automatically enabled when `options.tokens` is true | + +**Example** + +```js +const picomatch = require('picomatch'); +const result = picomatch.scan('!./foo/*.js', { tokens: true }); +console.log(result); +// { +// prefix: '!./', +// input: '!./foo/*.js', +// start: 3, +// base: 'foo', +// glob: '*.js', +// isBrace: false, +// isBracket: false, +// isGlob: true, +// isExtglob: false, +// isGlobstar: false, +// negated: true, +// maxDepth: 2, +// tokens: [ +// { value: '!./', depth: 0, isGlob: false, negated: true, isPrefix: true }, +// { value: 'foo', depth: 1, isGlob: false }, +// { value: '*.js', depth: 1, isGlob: true } +// ], +// slashes: [ 2, 6 ], +// parts: [ 'foo', '*.js' ] +// } +``` + +
    + +### Options Examples + +#### options.expandRange + +**Type**: `function` + +**Default**: `undefined` + +Custom function for expanding ranges in brace patterns. The [fill-range](https://github.com/jonschlinkert/fill-range) library is ideal for this purpose, or you can use custom code to do whatever you need. + +**Example** + +The following example shows how to create a glob that matches a folder + +```js +const fill = require('fill-range'); +const regex = pm.makeRe('foo/{01..25}/bar', { + expandRange(a, b) { + return `(${fill(a, b, { toRegex: true })})`; + } +}); + +console.log(regex); +//=> /^(?:foo\/((?:0[1-9]|1[0-9]|2[0-5]))\/bar)$/ + +console.log(regex.test('foo/00/bar')) // false +console.log(regex.test('foo/01/bar')) // true +console.log(regex.test('foo/10/bar')) // true +console.log(regex.test('foo/22/bar')) // true +console.log(regex.test('foo/25/bar')) // true +console.log(regex.test('foo/26/bar')) // false +``` + +#### options.format + +**Type**: `function` + +**Default**: `undefined` + +Custom function for formatting strings before they're matched. + +**Example** + +```js +// strip leading './' from strings +const format = str => str.replace(/^\.\//, ''); +const isMatch = picomatch('foo/*.js', { format }); +console.log(isMatch('./foo/bar.js')); //=> true +``` + +#### options.onMatch + +```js +const onMatch = ({ glob, regex, input, output }) => { + console.log({ glob, regex, input, output }); +}; + +const isMatch = picomatch('*', { onMatch }); +isMatch('foo'); +isMatch('bar'); +isMatch('baz'); +``` + +#### options.onIgnore + +```js +const onIgnore = ({ glob, regex, input, output }) => { + console.log({ glob, regex, input, output }); +}; + +const isMatch = picomatch('*', { onIgnore, ignore: 'f*' }); +isMatch('foo'); +isMatch('bar'); +isMatch('baz'); +``` + +#### options.onResult + +```js +const onResult = ({ glob, regex, input, output }) => { + console.log({ glob, regex, input, output }); +}; + +const isMatch = picomatch('*', { onResult, ignore: 'f*' }); +isMatch('foo'); +isMatch('bar'); +isMatch('baz'); +``` + +
    +
    + +## Globbing features + +* [Basic globbing](#basic-globbing) (Wildcard matching) +* [Advanced globbing](#advanced-globbing) (extglobs, posix brackets, brace matching) + +### Basic globbing + +| **Character** | **Description** | +| --- | --- | +| `*` | Matches any character zero or more times, excluding path separators. Does _not match_ path separators or hidden files or directories ("dotfiles"), unless explicitly enabled by setting the `dot` option to `true`. | +| `**` | Matches any character zero or more times, including path separators. Note that `**` will only match path separators (`/`, and `\\` with the `windows` option) when they are the only characters in a path segment. Thus, `foo**/bar` is equivalent to `foo*/bar`, and `foo/a**b/bar` is equivalent to `foo/a*b/bar`, and _more than two_ consecutive stars in a glob path segment are regarded as _a single star_. Thus, `foo/***/bar` is equivalent to `foo/*/bar`. | +| `?` | Matches any character excluding path separators one time. Does _not match_ path separators or leading dots. | +| `[abc]` | Matches any characters inside the brackets. For example, `[abc]` would match the characters `a`, `b` or `c`, and nothing else. | + +#### Matching behavior vs. Bash + +Picomatch's matching features and expected results in unit tests are based on Bash's unit tests and the Bash 4.3 specification, with the following exceptions: + +* Bash will match `foo/bar/baz` with `*`. Picomatch only matches nested directories with `**`. +* Bash greedily matches with negated extglobs. For example, Bash 4.3 says that `!(foo)*` should match `foo` and `foobar`, since the trailing `*` bracktracks to match the preceding pattern. This is very memory-inefficient, and IMHO, also incorrect. Picomatch would return `false` for both `foo` and `foobar`. + +
    + +### Advanced globbing + +* [extglobs](#extglobs) +* [POSIX brackets](#posix-brackets) +* [Braces](#brace-expansion) + +#### Extglobs + +| **Pattern** | **Description** | +| --- | --- | +| `@(pattern)` | Match _only one_ consecutive occurrence of `pattern` | +| `*(pattern)` | Match _zero or more_ consecutive occurrences of `pattern` | +| `+(pattern)` | Match _one or more_ consecutive occurrences of `pattern` | +| `?(pattern)` | Match _zero or **one**_ consecutive occurrences of `pattern` | +| `!(pattern)` | Match _anything but_ `pattern` | + +**Examples** + +```js +const pm = require('picomatch'); + +// *(pattern) matches ZERO or more of "pattern" +console.log(pm.isMatch('a', 'a*(z)')); // true +console.log(pm.isMatch('az', 'a*(z)')); // true +console.log(pm.isMatch('azzz', 'a*(z)')); // true + +// +(pattern) matches ONE or more of "pattern" +console.log(pm.isMatch('a', 'a+(z)')); // false +console.log(pm.isMatch('az', 'a+(z)')); // true +console.log(pm.isMatch('azzz', 'a+(z)')); // true + +// supports multiple extglobs +console.log(pm.isMatch('foo.bar', '!(foo).!(bar)')); // false + +// supports nested extglobs +console.log(pm.isMatch('foo.bar', '!(!(foo)).!(!(bar))')); // true + +// risky quantified extglobs are treated literally by default +console.log(pm.makeRe('+(a|aa)')); +//=> /^(?:\+\(a\|aa\))$/ + +// increase the limit to allow a small amount of nested quantified extglobs +console.log(pm.isMatch('aaa', '+(+(a))', { maxExtglobRecursion: 1 })); // true +``` + +#### POSIX brackets + +POSIX classes are disabled by default. Enable this feature by setting the `posix` option to true. + +**Enable POSIX bracket support** + +```js +console.log(pm.makeRe('[[:word:]]+', { posix: true })); +//=> /^(?:(?=.)[A-Za-z0-9_]+\/?)$/ +``` + +**Supported POSIX classes** + +The following named POSIX bracket expressions are supported: + +* `[:alnum:]` - Alphanumeric characters, equ `[a-zA-Z0-9]` +* `[:alpha:]` - Alphabetical characters, equivalent to `[a-zA-Z]`. +* `[:ascii:]` - ASCII characters, equivalent to `[\\x00-\\x7F]`. +* `[:blank:]` - Space and tab characters, equivalent to `[ \\t]`. +* `[:cntrl:]` - Control characters, equivalent to `[\\x00-\\x1F\\x7F]`. +* `[:digit:]` - Numerical digits, equivalent to `[0-9]`. +* `[:graph:]` - Graph characters, equivalent to `[\\x21-\\x7E]`. +* `[:lower:]` - Lowercase letters, equivalent to `[a-z]`. +* `[:print:]` - Print characters, equivalent to `[\\x20-\\x7E ]`. +* `[:punct:]` - Punctuation and symbols, equivalent to `[\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~]`. +* `[:space:]` - Extended space characters, equivalent to `[ \\t\\r\\n\\v\\f]`. +* `[:upper:]` - Uppercase letters, equivalent to `[A-Z]`. +* `[:word:]` - Word characters (letters, numbers and underscores), equivalent to `[A-Za-z0-9_]`. +* `[:xdigit:]` - Hexadecimal digits, equivalent to `[A-Fa-f0-9]`. + +See the [Bash Reference Manual](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html) for more information. + +### Braces + +Picomatch only does [brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html) of comma-delimited lists (e.g. `a/{b,c}/d`). For advanced matching with braces, use [micromatch](https://github.com/micromatch/micromatch), which supports advanced syntax such as ranges (e.g. `{01..03}`) and increments (e.g. `{2..10..2}`). + +### Matching special characters as literals + +If you wish to match the following special characters in a filepath, and you want to use these characters in your glob pattern, they must be escaped with backslashes or quotes: + +**Special Characters** + +Some characters that are used for matching in regular expressions are also regarded as valid file path characters on some platforms. + +To match any of the following characters as literals: `$^*+?()[] + +Examples: + +```js +console.log(pm.makeRe('foo/bar \\(1\\)')); +console.log(pm.makeRe('foo/bar \\(1\\)')); +``` + +
    +
    + +## Library Comparisons + +The following table shows which features are supported by [minimatch](https://github.com/isaacs/minimatch), [micromatch](https://github.com/micromatch/micromatch), [picomatch](https://github.com/micromatch/picomatch), [nanomatch](https://github.com/micromatch/nanomatch), [extglob](https://github.com/micromatch/extglob), [braces](https://github.com/micromatch/braces), and [expand-brackets](https://github.com/micromatch/expand-brackets). + +| **Feature** | `minimatch` | `micromatch` | `picomatch` | `nanomatch` | `extglob` | `braces` | `expand-brackets` | +| --- | --- | --- | --- | --- | --- | --- | --- | +| Wildcard matching (`*?+`) | ✔ | ✔ | ✔ | ✔ | - | - | - | +| Advancing globbing | ✔ | ✔ | ✔ | - | - | - | - | +| Brace _matching_ | ✔ | ✔ | ✔ | - | - | ✔ | - | +| Brace _expansion_ | ✔ | ✔ | - | - | - | ✔ | - | +| Extglobs | partial | ✔ | ✔ | - | ✔ | - | - | +| Posix brackets | - | ✔ | ✔ | - | - | - | ✔ | +| Regular expression syntax | - | ✔ | ✔ | ✔ | ✔ | - | ✔ | +| File system operations | - | - | - | - | - | - | - | + +
    +
    + +## Benchmarks + +Performance comparison of picomatch and minimatch. + +``` +# .makeRe star (*) + picomatch x 3,251,247 ops/sec ±0.25% (95 runs sampled) + minimatch x 497,224 ops/sec ±0.11% (100 runs sampled) + +# .makeRe star; dot=true (*) + picomatch x 2,624,035 ops/sec ±0.16% (98 runs sampled) + minimatch x 446,244 ops/sec ±0.63% (99 runs sampled) + +# .makeRe globstar (**) + picomatch x 2,524,465 ops/sec ±0.13% (99 runs sampled) + minimatch x 1,396,257 ops/sec ±0.58% (96 runs sampled) + +# .makeRe globstars (**/**/**) + picomatch x 2,545,674 ops/sec ±0.10% (99 runs sampled) + minimatch x 1,196,835 ops/sec ±0.63% (98 runs sampled) + +# .makeRe with leading star (*.txt) + picomatch x 2,537,708 ops/sec ±0.11% (100 runs sampled) + minimatch x 345,284 ops/sec ±0.64% (96 runs sampled) + +# .makeRe - basic braces ({a,b,c}*.txt) + picomatch x 505,430 ops/sec ±1.04% (94 runs sampled) + minimatch x 107,991 ops/sec ±0.54% (99 runs sampled) + +# .makeRe - short ranges ({a..z}*.txt) + picomatch x 371,179 ops/sec ±2.91% (77 runs sampled) + minimatch x 14,104 ops/sec ±0.61% (99 runs sampled) + +# .makeRe - medium ranges ({1..100000}*.txt) + picomatch x 384,958 ops/sec ±1.70% (82 runs sampled) + minimatch x 2.55 ops/sec ±3.22% (11 runs sampled) + +# .makeRe - long ranges ({1..10000000}*.txt) + picomatch x 382,552 ops/sec ±1.52% (71 runs sampled) + minimatch x 0.83 ops/sec ±5.67% (7 runs sampled)) +``` + +
    +
    + +## Philosophies + +The goal of this library is to be blazing fast, without compromising on accuracy. + +**Accuracy** + +The number one of goal of this library is accuracy. However, it's not unusual for different glob implementations to have different rules for matching behavior, even with simple wildcard matching. It gets increasingly more complicated when combinations of different features are combined, like when extglobs are combined with globstars, braces, slashes, and so on: `!(**/{a,b,*/c})`. + +Thus, given that there is no canonical glob specification to use as a single source of truth when differences of opinion arise regarding behavior, sometimes we have to implement our best judgement and rely on feedback from users to make improvements. + +**Performance** + +Although this library performs well in benchmarks, and in most cases it's faster than other popular libraries we benchmarked against, we will always choose accuracy over performance. It's not helpful to anyone if our library is faster at returning the wrong answer. + +
    +
    + +## About + +
    +Contributing + +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards. + +
    + +
    +Running Tests + +Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command: + +```sh +npm install && npm test +``` + +
    + +
    +Building docs + +_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_ + +To generate the readme, run the following command: + +```sh +npm install -g verbose/verb#dev verb-generate-readme && verb +``` + +
    + +### Author + +**Jon Schlinkert** + +* [GitHub Profile](https://github.com/jonschlinkert) +* [Twitter Profile](https://twitter.com/jonschlinkert) +* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert) + +### License + +Copyright © 2017-present, [Jon Schlinkert](https://github.com/jonschlinkert). +Released under the [MIT License](LICENSE). \ No newline at end of file diff --git a/frontend/node_modules/picomatch/index.js b/frontend/node_modules/picomatch/index.js new file mode 100644 index 0000000..a753b1d --- /dev/null +++ b/frontend/node_modules/picomatch/index.js @@ -0,0 +1,17 @@ +'use strict'; + +const pico = require('./lib/picomatch'); +const utils = require('./lib/utils'); + +function picomatch(glob, options, returnState = false) { + // default to os.platform() + if (options && (options.windows === null || options.windows === undefined)) { + // don't mutate the original options object + options = { ...options, windows: utils.isWindows() }; + } + + return pico(glob, options, returnState); +} + +Object.assign(picomatch, pico); +module.exports = picomatch; diff --git a/frontend/node_modules/picomatch/lib/constants.js b/frontend/node_modules/picomatch/lib/constants.js new file mode 100644 index 0000000..f0aeda7 --- /dev/null +++ b/frontend/node_modules/picomatch/lib/constants.js @@ -0,0 +1,184 @@ +'use strict'; + +const WIN_SLASH = '\\\\/'; +const WIN_NO_SLASH = `[^${WIN_SLASH}]`; + +const DEFAULT_MAX_EXTGLOB_RECURSION = 0; + +/** + * Posix glob regex + */ + +const DOT_LITERAL = '\\.'; +const PLUS_LITERAL = '\\+'; +const QMARK_LITERAL = '\\?'; +const SLASH_LITERAL = '\\/'; +const ONE_CHAR = '(?=.)'; +const QMARK = '[^/]'; +const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`; +const START_ANCHOR = `(?:^|${SLASH_LITERAL})`; +const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`; +const NO_DOT = `(?!${DOT_LITERAL})`; +const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`; +const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`; +const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`; +const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`; +const STAR = `${QMARK}*?`; +const SEP = '/'; + +const POSIX_CHARS = { + DOT_LITERAL, + PLUS_LITERAL, + QMARK_LITERAL, + SLASH_LITERAL, + ONE_CHAR, + QMARK, + END_ANCHOR, + DOTS_SLASH, + NO_DOT, + NO_DOTS, + NO_DOT_SLASH, + NO_DOTS_SLASH, + QMARK_NO_DOT, + STAR, + START_ANCHOR, + SEP +}; + +/** + * Windows glob regex + */ + +const WINDOWS_CHARS = { + ...POSIX_CHARS, + + SLASH_LITERAL: `[${WIN_SLASH}]`, + QMARK: WIN_NO_SLASH, + STAR: `${WIN_NO_SLASH}*?`, + DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`, + NO_DOT: `(?!${DOT_LITERAL})`, + NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, + NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`, + NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`, + QMARK_NO_DOT: `[^.${WIN_SLASH}]`, + START_ANCHOR: `(?:^|[${WIN_SLASH}])`, + END_ANCHOR: `(?:[${WIN_SLASH}]|$)`, + SEP: '\\' +}; + +/** + * POSIX Bracket Regex + */ + +const POSIX_REGEX_SOURCE = { + __proto__: null, + alnum: 'a-zA-Z0-9', + alpha: 'a-zA-Z', + ascii: '\\x00-\\x7F', + blank: ' \\t', + cntrl: '\\x00-\\x1F\\x7F', + digit: '0-9', + graph: '\\x21-\\x7E', + lower: 'a-z', + print: '\\x20-\\x7E ', + punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~', + space: ' \\t\\r\\n\\v\\f', + upper: 'A-Z', + word: 'A-Za-z0-9_', + xdigit: 'A-Fa-f0-9' +}; + +module.exports = { + DEFAULT_MAX_EXTGLOB_RECURSION, + MAX_LENGTH: 1024 * 64, + POSIX_REGEX_SOURCE, + + // regular expressions + REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, + REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/, + REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, + REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, + REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, + REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, + + // Replace globs with equivalent patterns to reduce parsing time. + REPLACEMENTS: { + __proto__: null, + '***': '*', + '**/**': '**', + '**/**/**': '**' + }, + + // Digits + CHAR_0: 48, /* 0 */ + CHAR_9: 57, /* 9 */ + + // Alphabet chars. + CHAR_UPPERCASE_A: 65, /* A */ + CHAR_LOWERCASE_A: 97, /* a */ + CHAR_UPPERCASE_Z: 90, /* Z */ + CHAR_LOWERCASE_Z: 122, /* z */ + + CHAR_LEFT_PARENTHESES: 40, /* ( */ + CHAR_RIGHT_PARENTHESES: 41, /* ) */ + + CHAR_ASTERISK: 42, /* * */ + + // Non-alphabetic chars. + CHAR_AMPERSAND: 38, /* & */ + CHAR_AT: 64, /* @ */ + CHAR_BACKWARD_SLASH: 92, /* \ */ + CHAR_CARRIAGE_RETURN: 13, /* \r */ + CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */ + CHAR_COLON: 58, /* : */ + CHAR_COMMA: 44, /* , */ + CHAR_DOT: 46, /* . */ + CHAR_DOUBLE_QUOTE: 34, /* " */ + CHAR_EQUAL: 61, /* = */ + CHAR_EXCLAMATION_MARK: 33, /* ! */ + CHAR_FORM_FEED: 12, /* \f */ + CHAR_FORWARD_SLASH: 47, /* / */ + CHAR_GRAVE_ACCENT: 96, /* ` */ + CHAR_HASH: 35, /* # */ + CHAR_HYPHEN_MINUS: 45, /* - */ + CHAR_LEFT_ANGLE_BRACKET: 60, /* < */ + CHAR_LEFT_CURLY_BRACE: 123, /* { */ + CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */ + CHAR_LINE_FEED: 10, /* \n */ + CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */ + CHAR_PERCENT: 37, /* % */ + CHAR_PLUS: 43, /* + */ + CHAR_QUESTION_MARK: 63, /* ? */ + CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */ + CHAR_RIGHT_CURLY_BRACE: 125, /* } */ + CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */ + CHAR_SEMICOLON: 59, /* ; */ + CHAR_SINGLE_QUOTE: 39, /* ' */ + CHAR_SPACE: 32, /* */ + CHAR_TAB: 9, /* \t */ + CHAR_UNDERSCORE: 95, /* _ */ + CHAR_VERTICAL_LINE: 124, /* | */ + CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */ + + /** + * Create EXTGLOB_CHARS + */ + + extglobChars(chars) { + return { + '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` }, + '?': { type: 'qmark', open: '(?:', close: ')?' }, + '+': { type: 'plus', open: '(?:', close: ')+' }, + '*': { type: 'star', open: '(?:', close: ')*' }, + '@': { type: 'at', open: '(?:', close: ')' } + }; + }, + + /** + * Create GLOB_CHARS + */ + + globChars(win32) { + return win32 === true ? WINDOWS_CHARS : POSIX_CHARS; + } +}; diff --git a/frontend/node_modules/picomatch/lib/parse.js b/frontend/node_modules/picomatch/lib/parse.js new file mode 100644 index 0000000..a85bb2d --- /dev/null +++ b/frontend/node_modules/picomatch/lib/parse.js @@ -0,0 +1,1416 @@ +'use strict'; + +const constants = require('./constants'); +const utils = require('./utils'); + +/** + * Constants + */ + +const { + MAX_LENGTH, + POSIX_REGEX_SOURCE, + REGEX_NON_SPECIAL_CHARS, + REGEX_SPECIAL_CHARS_BACKREF, + REPLACEMENTS +} = constants; + +/** + * Helpers + */ + +const expandRange = (args, options) => { + if (typeof options.expandRange === 'function') { + return options.expandRange(...args, options); + } + + args.sort(); + const value = `[${args.join('-')}]`; + + try { + /* eslint-disable-next-line no-new */ + new RegExp(value); + } catch (ex) { + return args.map(v => utils.escapeRegex(v)).join('..'); + } + + return value; +}; + +/** + * Create the message for a syntax error + */ + +const syntaxError = (type, char) => { + return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`; +}; + +const splitTopLevel = input => { + const parts = []; + let bracket = 0; + let paren = 0; + let quote = 0; + let value = ''; + let escaped = false; + + for (const ch of input) { + if (escaped === true) { + value += ch; + escaped = false; + continue; + } + + if (ch === '\\') { + value += ch; + escaped = true; + continue; + } + + if (ch === '"') { + quote = quote === 1 ? 0 : 1; + value += ch; + continue; + } + + if (quote === 0) { + if (ch === '[') { + bracket++; + } else if (ch === ']' && bracket > 0) { + bracket--; + } else if (bracket === 0) { + if (ch === '(') { + paren++; + } else if (ch === ')' && paren > 0) { + paren--; + } else if (ch === '|' && paren === 0) { + parts.push(value); + value = ''; + continue; + } + } + } + + value += ch; + } + + parts.push(value); + return parts; +}; + +const isPlainBranch = branch => { + let escaped = false; + + for (const ch of branch) { + if (escaped === true) { + escaped = false; + continue; + } + + if (ch === '\\') { + escaped = true; + continue; + } + + if (/[?*+@!()[\]{}]/.test(ch)) { + return false; + } + } + + return true; +}; + +const normalizeSimpleBranch = branch => { + let value = branch.trim(); + let changed = true; + + while (changed === true) { + changed = false; + + if (/^@\([^\\()[\]{}|]+\)$/.test(value)) { + value = value.slice(2, -1); + changed = true; + } + } + + if (!isPlainBranch(value)) { + return; + } + + return value.replace(/\\(.)/g, '$1'); +}; + +const hasRepeatedCharPrefixOverlap = branches => { + const values = branches.map(normalizeSimpleBranch).filter(Boolean); + + for (let i = 0; i < values.length; i++) { + for (let j = i + 1; j < values.length; j++) { + const a = values[i]; + const b = values[j]; + const char = a[0]; + + if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) { + continue; + } + + if (a === b || a.startsWith(b) || b.startsWith(a)) { + return true; + } + } + } + + return false; +}; + +const parseRepeatedExtglob = (pattern, requireEnd = true) => { + if ((pattern[0] !== '+' && pattern[0] !== '*') || pattern[1] !== '(') { + return; + } + + let bracket = 0; + let paren = 0; + let quote = 0; + let escaped = false; + + for (let i = 1; i < pattern.length; i++) { + const ch = pattern[i]; + + if (escaped === true) { + escaped = false; + continue; + } + + if (ch === '\\') { + escaped = true; + continue; + } + + if (ch === '"') { + quote = quote === 1 ? 0 : 1; + continue; + } + + if (quote === 1) { + continue; + } + + if (ch === '[') { + bracket++; + continue; + } + + if (ch === ']' && bracket > 0) { + bracket--; + continue; + } + + if (bracket > 0) { + continue; + } + + if (ch === '(') { + paren++; + continue; + } + + if (ch === ')') { + paren--; + + if (paren === 0) { + if (requireEnd === true && i !== pattern.length - 1) { + return; + } + + return { + type: pattern[0], + body: pattern.slice(2, i), + end: i + }; + } + } + } +}; + +const buildCharClassStar = chars => { + const source = chars.length === 1 + ? utils.escapeRegex(chars[0]) + : `[${chars.map(ch => utils.escapeRegex(ch)).join('')}]`; + + return `${source}*`; +}; + +const getStarExtglobSequenceChars = pattern => { + let index = 0; + const chars = []; + + while (index < pattern.length) { + const match = parseRepeatedExtglob(pattern.slice(index), false); + + if (!match || match.type !== '*') { + return; + } + + const branches = splitTopLevel(match.body).map(branch => branch.trim()); + if (branches.length !== 1) { + return; + } + + const branch = normalizeSimpleBranch(branches[0]); + if (!branch || branch.length !== 1) { + return; + } + + chars.push(branch); + index += match.end + 1; + } + + if (chars.length < 1) { + return; + } + + return chars; +}; + +const repeatedExtglobRecursion = pattern => { + let depth = 0; + let value = pattern.trim(); + let match = parseRepeatedExtglob(value); + + while (match) { + depth++; + value = match.body.trim(); + match = parseRepeatedExtglob(value); + } + + return depth; +}; + +const analyzeRepeatedExtglob = (body, options) => { + if (options.maxExtglobRecursion === false) { + return { risky: false }; + } + + const max = + typeof options.maxExtglobRecursion === 'number' + ? options.maxExtglobRecursion + : constants.DEFAULT_MAX_EXTGLOB_RECURSION; + + const branches = splitTopLevel(body).map(branch => branch.trim()); + + if (branches.length > 1) { + if ( + branches.some(branch => branch === '') || + branches.some(branch => /^[*?]+$/.test(branch)) || + hasRepeatedCharPrefixOverlap(branches) + ) { + return { risky: true }; + } + } + + // A repeated extglob is "risky" (prone to catastrophic backtracking) when a + // branch is itself a `*(...)` sequence, since that nests an unbounded quantifier + // inside the outer `+(...)`/`*(...)`. When *every* branch reduces to single + // characters we can emit one flat, ReDoS-safe character class that preserves the + // meaning of ALL branches (e.g. `+(*(a)|*(b))` -> `[ab]*`), rather than dropping + // every branch but the first. + const safeChars = []; + let sawStarSequence = false; + let combinable = true; + + for (const branch of branches) { + const chars = getStarExtglobSequenceChars(branch); + if (chars) { + sawStarSequence = true; + safeChars.push(...chars); + continue; + } + + const literal = normalizeSimpleBranch(branch); + if (literal && literal.length === 1) { + safeChars.push(literal); + continue; + } + + combinable = false; + + if (repeatedExtglobRecursion(branch) > max) { + return { risky: true }; + } + } + + if (sawStarSequence) { + return combinable + ? { risky: true, safeOutput: buildCharClassStar([...new Set(safeChars)]) } + : { risky: true }; + } + + return { risky: false }; +}; + +/** + * Parse the given input string. + * @param {String} input + * @param {Object} options + * @return {Object} + */ + +const parse = (input, options) => { + if (typeof input !== 'string') { + throw new TypeError('Expected a string'); + } + + input = REPLACEMENTS[input] || input; + + const opts = { ...options }; + const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; + + let len = input.length; + if (len > max) { + throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); + } + + const bos = { type: 'bos', value: '', output: opts.prepend || '' }; + const tokens = [bos]; + + const capture = opts.capture ? '' : '?:'; + + // create constants based on platform, for windows or posix + const PLATFORM_CHARS = constants.globChars(opts.windows); + const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS); + + const { + DOT_LITERAL, + PLUS_LITERAL, + SLASH_LITERAL, + ONE_CHAR, + DOTS_SLASH, + NO_DOT, + NO_DOT_SLASH, + NO_DOTS_SLASH, + QMARK, + QMARK_NO_DOT, + STAR, + START_ANCHOR + } = PLATFORM_CHARS; + + const globstar = opts => { + return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; + }; + + const nodot = opts.dot ? '' : NO_DOT; + const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT; + let star = opts.bash === true ? globstar(opts) : STAR; + + if (opts.capture) { + star = `(${star})`; + } + + // minimatch options support + if (typeof opts.noext === 'boolean') { + opts.noextglob = opts.noext; + } + + const state = { + input, + index: -1, + start: 0, + dot: opts.dot === true, + consumed: '', + output: '', + prefix: '', + backtrack: false, + negated: false, + brackets: 0, + braces: 0, + parens: 0, + quotes: 0, + globstar: false, + tokens + }; + + input = utils.removePrefix(input, state); + len = input.length; + + const extglobs = []; + const braces = []; + const stack = []; + let prev = bos; + let value; + + /** + * Tokenizing helpers + */ + + const eos = () => state.index === len - 1; + const peek = state.peek = (n = 1) => input[state.index + n]; + const advance = state.advance = () => input[++state.index] || ''; + const remaining = () => input.slice(state.index + 1); + const consume = (value = '', num = 0) => { + state.consumed += value; + state.index += num; + }; + + const append = token => { + state.output += token.output != null ? token.output : token.value; + consume(token.value); + }; + + const negate = () => { + let count = 1; + + while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) { + advance(); + state.start++; + count++; + } + + if (count % 2 === 0) { + return false; + } + + state.negated = true; + state.start++; + return true; + }; + + const increment = type => { + state[type]++; + stack.push(type); + }; + + const decrement = type => { + state[type]--; + stack.pop(); + }; + + /** + * Push tokens onto the tokens array. This helper speeds up + * tokenizing by 1) helping us avoid backtracking as much as possible, + * and 2) helping us avoid creating extra tokens when consecutive + * characters are plain text. This improves performance and simplifies + * lookbehinds. + */ + + const push = tok => { + if (prev.type === 'globstar') { + const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace'); + const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren')); + + if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) { + state.output = state.output.slice(0, -prev.output.length); + prev.type = 'star'; + prev.value = '*'; + prev.output = star; + state.output += prev.output; + } + } + + if (extglobs.length && tok.type !== 'paren') { + extglobs[extglobs.length - 1].inner += tok.value; + } + + if (tok.value || tok.output) append(tok); + if (prev && prev.type === 'text' && tok.type === 'text') { + prev.output = (prev.output || prev.value) + tok.value; + prev.value += tok.value; + return; + } + + tok.prev = prev; + tokens.push(tok); + prev = tok; + }; + + const extglobOpen = (type, value) => { + const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' }; + + token.prev = prev; + token.parens = state.parens; + token.output = state.output; + token.startIndex = state.index; + token.tokensIndex = tokens.length; + const output = (opts.capture ? '(' : '') + token.open; + + increment('parens'); + push({ type, value, output: state.output ? '' : ONE_CHAR }); + push({ type: 'paren', extglob: true, value: advance(), output }); + extglobs.push(token); + }; + + const extglobClose = token => { + const literal = input.slice(token.startIndex, state.index + 1); + const body = input.slice(token.startIndex + 2, state.index); + const analysis = analyzeRepeatedExtglob(body, opts); + + if ((token.type === 'plus' || token.type === 'star') && analysis.risky) { + const safeOutput = analysis.safeOutput + ? (token.output ? '' : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) + : undefined; + const open = tokens[token.tokensIndex]; + + open.type = 'text'; + open.value = literal; + open.output = safeOutput || utils.escapeRegex(literal); + + for (let i = token.tokensIndex + 1; i < tokens.length; i++) { + tokens[i].value = ''; + tokens[i].output = ''; + delete tokens[i].suffix; + } + + state.output = token.output + open.output; + state.backtrack = true; + + push({ type: 'paren', extglob: true, value, output: '' }); + decrement('parens'); + return; + } + + let output = token.close + (opts.capture ? ')' : ''); + let rest; + + if (token.type === 'negate') { + let extglobStar = star; + + if (token.inner && token.inner.length > 1 && token.inner.includes('/')) { + extglobStar = globstar(opts); + } + + if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) { + output = token.close = `)$))${extglobStar}`; + } + + if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) { + // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis. + // In this case, we need to parse the string and use it in the output of the original pattern. + // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`. + // + // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`. + const expression = parse(rest, { ...options, fastpaths: false }).output; + + output = token.close = `)${expression})${extglobStar})`; + } + + if (token.prev.type === 'bos') { + state.negatedExtglob = true; + } + } + + push({ type: 'paren', extglob: true, value, output }); + decrement('parens'); + }; + + /** + * Fast paths + */ + + if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) { + let backslashes = false; + + let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => { + if (first === '\\') { + backslashes = true; + return m; + } + + if (first === '?') { + if (esc) { + return esc + first + (rest ? QMARK.repeat(rest.length) : ''); + } + if (index === 0) { + return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : ''); + } + return QMARK.repeat(chars.length); + } + + if (first === '.') { + return DOT_LITERAL.repeat(chars.length); + } + + if (first === '*') { + if (esc) { + return esc + first + (rest ? star : ''); + } + return star; + } + return esc ? m : `\\${m}`; + }); + + if (backslashes === true) { + if (opts.unescape === true) { + output = output.replace(/\\/g, ''); + } else { + output = output.replace(/\\+/g, m => { + return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : ''); + }); + } + } + + if (output === input && opts.contains === true) { + state.output = input; + return state; + } + + state.output = utils.wrapOutput(output, state, options); + return state; + } + + /** + * Tokenize input until we reach end-of-string + */ + + while (!eos()) { + value = advance(); + + if (value === '\u0000') { + continue; + } + + /** + * Escaped characters + */ + + if (value === '\\') { + const next = peek(); + + if (next === '/' && opts.bash !== true) { + continue; + } + + if (next === '.' || next === ';') { + continue; + } + + if (!next) { + value += '\\'; + push({ type: 'text', value }); + continue; + } + + // collapse slashes to reduce potential for exploits + const match = /^\\+/.exec(remaining()); + let slashes = 0; + + if (match && match[0].length > 2) { + slashes = match[0].length; + state.index += slashes; + if (slashes % 2 !== 0) { + value += '\\'; + } + } + + if (opts.unescape === true) { + value = advance(); + } else { + value += advance(); + } + + if (state.brackets === 0) { + push({ type: 'text', value }); + continue; + } + } + + /** + * If we're inside a regex character class, continue + * until we reach the closing bracket. + */ + + if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) { + if (opts.posix !== false && value === ':') { + const inner = prev.value.slice(1); + if (inner.includes('[')) { + prev.posix = true; + + if (inner.includes(':')) { + const idx = prev.value.lastIndexOf('['); + const pre = prev.value.slice(0, idx); + const rest = prev.value.slice(idx + 2); + const posix = POSIX_REGEX_SOURCE[rest]; + if (posix) { + prev.value = pre + posix; + state.backtrack = true; + advance(); + + if (!bos.output && tokens.indexOf(prev) === 1) { + bos.output = ONE_CHAR; + } + continue; + } + } + } + } + + if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) { + value = `\\${value}`; + } + + if (value === ']' && (prev.value === '[' || prev.value === '[^')) { + value = `\\${value}`; + } + + if (opts.posix === true && value === '!' && prev.value === '[') { + value = '^'; + } + + prev.value += value; + append({ value }); + continue; + } + + /** + * If we're inside a quoted string, continue + * until we reach the closing double quote. + */ + + if (state.quotes === 1 && value !== '"') { + value = utils.escapeRegex(value); + prev.value += value; + append({ value }); + continue; + } + + /** + * Double quotes + */ + + if (value === '"') { + state.quotes = state.quotes === 1 ? 0 : 1; + if (opts.keepQuotes === true) { + push({ type: 'text', value }); + } + continue; + } + + /** + * Parentheses + */ + + if (value === '(') { + increment('parens'); + push({ type: 'paren', value }); + continue; + } + + if (value === ')') { + if (state.parens === 0 && opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('opening', '(')); + } + + const extglob = extglobs[extglobs.length - 1]; + if (extglob && state.parens === extglob.parens + 1) { + extglobClose(extglobs.pop()); + continue; + } + + push({ type: 'paren', value, output: state.parens ? ')' : '\\)' }); + decrement('parens'); + continue; + } + + /** + * Square brackets + */ + + if (value === '[') { + if (opts.nobracket === true || !remaining().includes(']')) { + if (opts.nobracket !== true && opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('closing', ']')); + } + + value = `\\${value}`; + } else { + increment('brackets'); + } + + push({ type: 'bracket', value }); + continue; + } + + if (value === ']') { + if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) { + push({ type: 'text', value, output: `\\${value}` }); + continue; + } + + if (state.brackets === 0) { + if (opts.strictBrackets === true) { + throw new SyntaxError(syntaxError('opening', '[')); + } + + push({ type: 'text', value, output: `\\${value}` }); + continue; + } + + decrement('brackets'); + + const prevValue = prev.value.slice(1); + if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) { + value = `/${value}`; + } + + prev.value += value; + append({ value }); + + // when literal brackets are explicitly disabled + // assume we should match with a regex character class + if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) { + continue; + } + + const escaped = utils.escapeRegex(prev.value); + state.output = state.output.slice(0, -prev.value.length); + + // when literal brackets are explicitly enabled + // assume we should escape the brackets to match literal characters + if (opts.literalBrackets === true) { + state.output += escaped; + prev.value = escaped; + continue; + } + + // when the user specifies nothing, try to match both + prev.value = `(${capture}${escaped}|${prev.value})`; + state.output += prev.value; + continue; + } + + /** + * Braces + */ + + if (value === '{' && opts.nobrace !== true) { + increment('braces'); + + const open = { + type: 'brace', + value, + output: '(', + outputIndex: state.output.length, + tokensIndex: state.tokens.length + }; + + braces.push(open); + push(open); + continue; + } + + if (value === '}') { + const brace = braces[braces.length - 1]; + + if (opts.nobrace === true || !brace) { + push({ type: 'text', value, output: value }); + continue; + } + + let output = ')'; + + if (brace.dots === true) { + const arr = tokens.slice(); + const range = []; + + for (let i = arr.length - 1; i >= 0; i--) { + tokens.pop(); + if (arr[i].type === 'brace') { + break; + } + if (arr[i].type !== 'dots') { + range.unshift(arr[i].value); + } + } + + output = expandRange(range, opts); + state.backtrack = true; + } + + if (brace.comma !== true && brace.dots !== true) { + const out = state.output.slice(0, brace.outputIndex); + const toks = state.tokens.slice(brace.tokensIndex); + brace.value = brace.output = '\\{'; + value = output = '\\}'; + state.output = out; + for (const t of toks) { + state.output += (t.output || t.value); + } + } + + push({ type: 'brace', value, output }); + decrement('braces'); + braces.pop(); + continue; + } + + /** + * Pipes + */ + + if (value === '|') { + if (extglobs.length > 0) { + extglobs[extglobs.length - 1].conditions++; + } + push({ type: 'text', value }); + continue; + } + + /** + * Commas + */ + + if (value === ',') { + let output = value; + + const brace = braces[braces.length - 1]; + if (brace && stack[stack.length - 1] === 'braces') { + brace.comma = true; + output = '|'; + } + + push({ type: 'comma', value, output }); + continue; + } + + /** + * Slashes + */ + + if (value === '/') { + // if the beginning of the glob is "./", advance the start + // to the current index, and don't add the "./" characters + // to the state. This greatly simplifies lookbehinds when + // checking for BOS characters like "!" and "." (not "./") + if (prev.type === 'dot' && state.index === state.start + 1) { + state.start = state.index + 1; + state.consumed = ''; + state.output = ''; + tokens.pop(); + prev = bos; // reset "prev" to the first token + continue; + } + + push({ type: 'slash', value, output: SLASH_LITERAL }); + continue; + } + + /** + * Dots + */ + + if (value === '.') { + if (state.braces > 0 && prev.type === 'dot') { + if (prev.value === '.') prev.output = DOT_LITERAL; + const brace = braces[braces.length - 1]; + prev.type = 'dots'; + prev.output += value; + prev.value += value; + brace.dots = true; + continue; + } + + if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') { + push({ type: 'text', value, output: DOT_LITERAL }); + continue; + } + + push({ type: 'dot', value, output: DOT_LITERAL }); + continue; + } + + /** + * Question marks + */ + + if (value === '?') { + const isGroup = prev && prev.value === '('; + if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('qmark', value); + continue; + } + + if (prev && prev.type === 'paren') { + const next = peek(); + let output = value; + + if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) { + output = `\\${value}`; + } + + push({ type: 'text', value, output }); + continue; + } + + if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) { + push({ type: 'qmark', value, output: QMARK_NO_DOT }); + continue; + } + + push({ type: 'qmark', value, output: QMARK }); + continue; + } + + /** + * Exclamation + */ + + if (value === '!') { + if (opts.noextglob !== true && peek() === '(') { + if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) { + extglobOpen('negate', value); + continue; + } + } + + if (opts.nonegate !== true && state.index === 0) { + negate(); + continue; + } + } + + /** + * Plus + */ + + if (value === '+') { + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + extglobOpen('plus', value); + continue; + } + + if ((prev && prev.value === '(') || opts.regex === false) { + push({ type: 'plus', value, output: PLUS_LITERAL }); + continue; + } + + if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) { + push({ type: 'plus', value }); + continue; + } + + push({ type: 'plus', value: PLUS_LITERAL }); + continue; + } + + /** + * Plain text + */ + + if (value === '@') { + if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') { + push({ type: 'at', extglob: true, value, output: '' }); + continue; + } + + push({ type: 'text', value }); + continue; + } + + /** + * Plain text + */ + + if (value !== '*') { + if (value === '$' || value === '^') { + value = `\\${value}`; + } + + const match = REGEX_NON_SPECIAL_CHARS.exec(remaining()); + if (match) { + value += match[0]; + state.index += match[0].length; + } + + push({ type: 'text', value }); + continue; + } + + /** + * Stars + */ + + if (prev && (prev.type === 'globstar' || prev.star === true)) { + prev.type = 'star'; + prev.star = true; + prev.value += value; + prev.output = star; + state.backtrack = true; + state.globstar = true; + consume(value); + continue; + } + + let rest = remaining(); + if (opts.noextglob !== true && /^\([^?]/.test(rest)) { + extglobOpen('star', value); + continue; + } + + if (prev.type === 'star') { + if (opts.noglobstar === true) { + consume(value); + continue; + } + + const prior = prev.prev; + const before = prior.prev; + const isStart = prior.type === 'slash' || prior.type === 'bos'; + const afterStar = before && (before.type === 'star' || before.type === 'globstar'); + + if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) { + push({ type: 'star', value, output: '' }); + continue; + } + + const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace'); + const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren'); + if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) { + push({ type: 'star', value, output: '' }); + continue; + } + + // strip consecutive `/**/` + while (rest.slice(0, 3) === '/**') { + const after = input[state.index + 4]; + if (after && after !== '/') { + break; + } + rest = rest.slice(3); + consume('/**', 3); + } + + if (prior.type === 'bos' && eos()) { + prev.type = 'globstar'; + prev.value += value; + prev.output = globstar(opts); + state.output = prev.output; + state.globstar = true; + consume(value); + continue; + } + + if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) { + state.output = state.output.slice(0, -(prior.output + prev.output).length); + prior.output = `(?:${prior.output}`; + + prev.type = 'globstar'; + prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)'); + prev.value += value; + state.globstar = true; + state.output += prior.output + prev.output; + consume(value); + continue; + } + + if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') { + const end = rest[1] !== void 0 ? '|$' : ''; + + state.output = state.output.slice(0, -(prior.output + prev.output).length); + prior.output = `(?:${prior.output}`; + + prev.type = 'globstar'; + prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`; + prev.value += value; + + state.output += prior.output + prev.output; + state.globstar = true; + + consume(value + advance()); + + push({ type: 'slash', value: '/', output: '' }); + continue; + } + + if (prior.type === 'bos' && rest[0] === '/') { + prev.type = 'globstar'; + prev.value += value; + prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`; + state.output = prev.output; + state.globstar = true; + consume(value + advance()); + push({ type: 'slash', value: '/', output: '' }); + continue; + } + + // remove single star from output + state.output = state.output.slice(0, -prev.output.length); + + // reset previous token to globstar + prev.type = 'globstar'; + prev.output = globstar(opts); + prev.value += value; + + // reset output with globstar + state.output += prev.output; + state.globstar = true; + consume(value); + continue; + } + + const token = { type: 'star', value, output: star }; + + if (opts.bash === true) { + token.output = '.*?'; + if (prev.type === 'bos' || prev.type === 'slash') { + token.output = nodot + token.output; + } + push(token); + continue; + } + + if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) { + token.output = value; + push(token); + continue; + } + + if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') { + if (prev.type === 'dot') { + state.output += NO_DOT_SLASH; + prev.output += NO_DOT_SLASH; + + } else if (opts.dot === true) { + state.output += NO_DOTS_SLASH; + prev.output += NO_DOTS_SLASH; + + } else { + state.output += nodot; + prev.output += nodot; + } + + if (peek() !== '*') { + state.output += ONE_CHAR; + prev.output += ONE_CHAR; + } + } + + push(token); + } + + while (state.brackets > 0) { + if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']')); + state.output = utils.escapeLast(state.output, '['); + decrement('brackets'); + } + + while (state.parens > 0) { + if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')')); + state.output = utils.escapeLast(state.output, '('); + decrement('parens'); + } + + while (state.braces > 0) { + if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}')); + state.output = utils.escapeLast(state.output, '{'); + decrement('braces'); + } + + if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) { + push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` }); + } + + // rebuild the output if we had to backtrack at any point + if (state.backtrack === true) { + state.output = ''; + + for (const token of state.tokens) { + state.output += token.output != null ? token.output : token.value; + + if (token.suffix) { + state.output += token.suffix; + } + } + } + + return state; +}; + +/** + * Fast paths for creating regular expressions for common glob patterns. + * This can significantly speed up processing and has very little downside + * impact when none of the fast paths match. + */ + +parse.fastpaths = (input, options) => { + const opts = { ...options }; + const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH; + const len = input.length; + if (len > max) { + throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`); + } + + input = REPLACEMENTS[input] || input; + + // create constants based on platform, for windows or posix + const { + DOT_LITERAL, + SLASH_LITERAL, + ONE_CHAR, + DOTS_SLASH, + NO_DOT, + NO_DOTS, + NO_DOTS_SLASH, + STAR, + START_ANCHOR + } = constants.globChars(opts.windows); + + const nodot = opts.dot ? NO_DOTS : NO_DOT; + const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT; + const capture = opts.capture ? '' : '?:'; + const state = { negated: false, prefix: '' }; + let star = opts.bash === true ? '.*?' : STAR; + + if (opts.capture) { + star = `(${star})`; + } + + const globstar = opts => { + if (opts.noglobstar === true) return star; + return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`; + }; + + const create = str => { + switch (str) { + case '*': + return `${nodot}${ONE_CHAR}${star}`; + + case '.*': + return `${DOT_LITERAL}${ONE_CHAR}${star}`; + + case '*.*': + return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; + + case '*/*': + return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`; + + case '**': + return nodot + globstar(opts); + + case '**/*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`; + + case '**/*.*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`; + + case '**/.*': + return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`; + + default: { + const match = /^(.*?)\.(\w+)$/.exec(str); + if (!match) return; + + const source = create(match[1]); + if (!source) return; + + return source + DOT_LITERAL + match[2]; + } + } + }; + + const output = utils.removePrefix(input, state); + let source = create(output); + + if (source && opts.strictSlashes !== true) { + source += `${SLASH_LITERAL}?`; + } + + return source; +}; + +module.exports = parse; diff --git a/frontend/node_modules/picomatch/lib/picomatch.js b/frontend/node_modules/picomatch/lib/picomatch.js new file mode 100644 index 0000000..9c2bfd5 --- /dev/null +++ b/frontend/node_modules/picomatch/lib/picomatch.js @@ -0,0 +1,361 @@ +'use strict'; + +const scan = require('./scan'); +const parse = require('./parse'); +const utils = require('./utils'); +const constants = require('./constants'); +const isObject = val => val && typeof val === 'object' && !Array.isArray(val); + +/** + * Creates a matcher function from one or more glob patterns. The + * returned function takes a string to match as its first argument, + * and returns true if the string is a match. The returned matcher + * function also takes a boolean as the second argument that, when true, + * returns an object with additional information. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch(glob[, options]); + * + * const isMatch = picomatch('*.!(*a)'); + * console.log(isMatch('a.a')); //=> false + * console.log(isMatch('a.b')); //=> true + * + * // For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection. + * const picomatch = require('picomatch/posix'); + * // the same API, defaulting to posix paths + * const isMatch = picomatch('a/*'); + * console.log(isMatch('a\\b')); //=> false + * console.log(isMatch('a/b')); //=> true + * + * // you can still configure the matcher function to accept windows paths + * const isMatch = picomatch('a/*', { options: windows }); + * console.log(isMatch('a\\b')); //=> true + * console.log(isMatch('a/b')); //=> true + * ``` + * @name picomatch + * @param {String|Array} `globs` One or more glob patterns. + * @param {Object=} `options` + * @return {Function=} Returns a matcher function. + * @api public + */ + +const picomatch = (glob, options, returnState = false) => { + if (Array.isArray(glob)) { + const fns = glob.map(input => picomatch(input, options, returnState)); + const arrayMatcher = str => { + for (const isMatch of fns) { + const state = isMatch(str); + if (state) return state; + } + return false; + }; + return arrayMatcher; + } + + const isState = isObject(glob) && glob.tokens && glob.input; + + if (glob === '' || (typeof glob !== 'string' && !isState)) { + throw new TypeError('Expected pattern to be a non-empty string'); + } + + const opts = options || {}; + const posix = opts.windows; + const regex = isState + ? picomatch.compileRe(glob, options) + : picomatch.makeRe(glob, options, false, true); + + const state = regex.state; + delete regex.state; + + let isIgnored = () => false; + if (opts.ignore) { + const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null }; + isIgnored = picomatch(opts.ignore, ignoreOpts, returnState); + } + + const matcher = (input, returnObject = false) => { + const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix }); + const result = { glob, state, regex, posix, input, output, match, isMatch }; + + if (typeof opts.onResult === 'function') { + opts.onResult(result); + } + + if (isMatch === false) { + result.isMatch = false; + return returnObject ? result : false; + } + + if (isIgnored(input)) { + if (typeof opts.onIgnore === 'function') { + opts.onIgnore(result); + } + result.isMatch = false; + return returnObject ? result : false; + } + + if (typeof opts.onMatch === 'function') { + opts.onMatch(result); + } + return returnObject ? result : true; + }; + + if (returnState) { + matcher.state = state; + } + + return matcher; +}; + +/** + * Test `input` with the given `regex`. This is used by the main + * `picomatch()` function to test the input string. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.test(input, regex[, options]); + * + * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/)); + * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' } + * ``` + * @param {String} `input` String to test. + * @param {RegExp} `regex` + * @return {Object} Returns an object with matching info. + * @api public + */ + +picomatch.test = (input, regex, options, { glob, posix } = {}) => { + if (typeof input !== 'string') { + throw new TypeError('Expected input to be a string'); + } + + if (input === '') { + return { isMatch: false, output: '' }; + } + + const opts = options || {}; + const format = opts.format || (posix ? utils.toPosixSlashes : null); + let match = input === glob; + let output = (match && format) ? format(input) : input; + + if (match === false) { + output = format ? format(input) : input; + match = output === glob; + } + + if (match === false || opts.capture === true) { + if (opts.matchBase === true || opts.basename === true) { + match = picomatch.matchBase(input, regex, options, posix); + } else { + match = regex.exec(output); + } + } + + return { isMatch: Boolean(match), match, output }; +}; + +/** + * Match the basename of a filepath. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.matchBase(input, glob[, options]); + * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true + * ``` + * @param {String} `input` String to test. + * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe). + * @return {Boolean} + * @api public + */ + +picomatch.matchBase = (input, glob, options, posix = options && options.windows) => { + const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options); + return regex.test(utils.basename(input, { windows: posix })); +}; + +/** + * Returns true if **any** of the given glob `patterns` match the specified `string`. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.isMatch(string, patterns[, options]); + * + * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true + * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false + * ``` + * @param {String|Array} str The string to test. + * @param {String|Array} patterns One or more glob patterns to use for matching. + * @param {Object} [options] See available [options](#options). + * @return {Boolean} Returns true if any patterns match `str` + * @api public + */ + +picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str); + +/** + * Parse a glob pattern to create the source string for a regular + * expression. + * + * ```js + * const picomatch = require('picomatch'); + * const result = picomatch.parse(pattern[, options]); + * ``` + * @param {String} `pattern` + * @param {Object} `options` + * @return {Object} Returns an object with useful properties and output to be used as a regex source string. + * @api public + */ + +picomatch.parse = (pattern, options) => { + if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options)); + return parse(pattern, { ...options, fastpaths: false }); +}; + +/** + * Scan a glob pattern to separate the pattern into segments. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.scan(input[, options]); + * + * const result = picomatch.scan('!./foo/*.js'); + * console.log(result); + * { prefix: '!./', + * input: '!./foo/*.js', + * start: 3, + * base: 'foo', + * glob: '*.js', + * isBrace: false, + * isBracket: false, + * isGlob: true, + * isExtglob: false, + * isGlobstar: false, + * negated: true } + * ``` + * @param {String} `input` Glob pattern to scan. + * @param {Object} `options` + * @return {Object} Returns an object with + * @api public + */ + +picomatch.scan = (input, options) => scan(input, options); + +/** + * Compile a regular expression from the `state` object returned by the + * [parse()](#parse) method. + * + * ```js + * const picomatch = require('picomatch'); + * const state = picomatch.parse('*.js'); + * // picomatch.compileRe(state[, options]); + * + * console.log(picomatch.compileRe(state)); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` + * @param {Object} `state` + * @param {Object} `options` + * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser. + * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging. + * @return {RegExp} + * @api public + */ + +picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => { + if (returnOutput === true) { + return state.output; + } + + const opts = options || {}; + const prepend = opts.contains ? '' : '^'; + const append = opts.contains ? '' : '$'; + + let source = `${prepend}(?:${state.output})${append}`; + if (state && state.negated === true) { + source = `^(?!${source}).*$`; + } + + const regex = picomatch.toRegex(source, options); + if (returnState === true) { + regex.state = state; + } + + return regex; +}; + +/** + * Create a regular expression from a parsed glob pattern. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.makeRe(state[, options]); + * + * const result = picomatch.makeRe('*.js'); + * console.log(result); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` + * @param {String} `state` The object returned from the `.parse` method. + * @param {Object} `options` + * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result. + * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression. + * @return {RegExp} Returns a regex created from the given pattern. + * @api public + */ + +picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => { + if (!input || typeof input !== 'string') { + throw new TypeError('Expected a non-empty string'); + } + + let parsed = { negated: false, fastpaths: true }; + + if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) { + parsed.output = parse.fastpaths(input, options); + } + + if (!parsed.output) { + parsed = parse(input, options); + } + + return picomatch.compileRe(parsed, options, returnOutput, returnState); +}; + +/** + * Create a regular expression from the given regex source string. + * + * ```js + * const picomatch = require('picomatch'); + * // picomatch.toRegex(source[, options]); + * + * const { output } = picomatch.parse('*.js'); + * console.log(picomatch.toRegex(output)); + * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/ + * ``` + * @param {String} `source` Regular expression source string. + * @param {Object} `options` + * @return {RegExp} + * @api public + */ + +picomatch.toRegex = (source, options) => { + try { + const opts = options || {}; + return new RegExp(source, opts.flags || (opts.nocase ? 'i' : '')); + } catch (err) { + if (options && options.debug === true) throw err; + return /$^/; + } +}; + +/** + * Picomatch constants. + * @return {Object} + */ + +picomatch.constants = constants; + +/** + * Expose "picomatch" + */ + +module.exports = picomatch; diff --git a/frontend/node_modules/picomatch/lib/scan.js b/frontend/node_modules/picomatch/lib/scan.js new file mode 100644 index 0000000..e59cd7a --- /dev/null +++ b/frontend/node_modules/picomatch/lib/scan.js @@ -0,0 +1,391 @@ +'use strict'; + +const utils = require('./utils'); +const { + CHAR_ASTERISK, /* * */ + CHAR_AT, /* @ */ + CHAR_BACKWARD_SLASH, /* \ */ + CHAR_COMMA, /* , */ + CHAR_DOT, /* . */ + CHAR_EXCLAMATION_MARK, /* ! */ + CHAR_FORWARD_SLASH, /* / */ + CHAR_LEFT_CURLY_BRACE, /* { */ + CHAR_LEFT_PARENTHESES, /* ( */ + CHAR_LEFT_SQUARE_BRACKET, /* [ */ + CHAR_PLUS, /* + */ + CHAR_QUESTION_MARK, /* ? */ + CHAR_RIGHT_CURLY_BRACE, /* } */ + CHAR_RIGHT_PARENTHESES, /* ) */ + CHAR_RIGHT_SQUARE_BRACKET /* ] */ +} = require('./constants'); + +const isPathSeparator = code => { + return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; +}; + +const depth = token => { + if (token.isPrefix !== true) { + token.depth = token.isGlobstar ? Infinity : 1; + } +}; + +/** + * Quickly scans a glob pattern and returns an object with a handful of + * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists), + * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not + * with `!(`) and `negatedExtglob` (true if the path starts with `!(`). + * + * ```js + * const pm = require('picomatch'); + * console.log(pm.scan('foo/bar/*.js')); + * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' } + * ``` + * @param {String} `str` + * @param {Object} `options` + * @return {Object} Returns an object with tokens and regex source string. + * @api public + */ + +const scan = (input, options) => { + const opts = options || {}; + + const length = input.length - 1; + const scanToEnd = opts.parts === true || opts.scanToEnd === true; + const slashes = []; + const tokens = []; + const parts = []; + + let str = input; + let index = -1; + let start = 0; + let lastIndex = 0; + let isBrace = false; + let isBracket = false; + let isGlob = false; + let isExtglob = false; + let isGlobstar = false; + let braceEscaped = false; + let backslashes = false; + let negated = false; + let negatedExtglob = false; + let finished = false; + let braces = 0; + let prev; + let code; + let token = { value: '', depth: 0, isGlob: false }; + + const eos = () => index >= length; + const peek = () => str.charCodeAt(index + 1); + const advance = () => { + prev = code; + return str.charCodeAt(++index); + }; + + while (index < length) { + code = advance(); + let next; + + if (code === CHAR_BACKWARD_SLASH) { + backslashes = token.backslashes = true; + code = advance(); + + if (code === CHAR_LEFT_CURLY_BRACE) { + braceEscaped = true; + } + continue; + } + + if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) { + braces++; + + while (eos() !== true && (code = advance())) { + if (code === CHAR_BACKWARD_SLASH) { + backslashes = token.backslashes = true; + advance(); + continue; + } + + if (code === CHAR_LEFT_CURLY_BRACE) { + braces++; + continue; + } + + if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) { + isBrace = token.isBrace = true; + isGlob = token.isGlob = true; + finished = true; + + if (scanToEnd === true) { + continue; + } + + break; + } + + if (braceEscaped !== true && code === CHAR_COMMA) { + isBrace = token.isBrace = true; + isGlob = token.isGlob = true; + finished = true; + + if (scanToEnd === true) { + continue; + } + + break; + } + + if (code === CHAR_RIGHT_CURLY_BRACE) { + braces--; + + if (braces === 0) { + braceEscaped = false; + isBrace = token.isBrace = true; + finished = true; + break; + } + } + } + + if (scanToEnd === true) { + continue; + } + + break; + } + + if (code === CHAR_FORWARD_SLASH) { + slashes.push(index); + tokens.push(token); + token = { value: '', depth: 0, isGlob: false }; + + if (finished === true) continue; + if (prev === CHAR_DOT && index === (start + 1)) { + start += 2; + continue; + } + + lastIndex = index + 1; + continue; + } + + if (opts.noext !== true) { + const isExtglobChar = code === CHAR_PLUS + || code === CHAR_AT + || code === CHAR_ASTERISK + || code === CHAR_QUESTION_MARK + || code === CHAR_EXCLAMATION_MARK; + + if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) { + isGlob = token.isGlob = true; + isExtglob = token.isExtglob = true; + finished = true; + if (code === CHAR_EXCLAMATION_MARK && index === start) { + negatedExtglob = true; + } + + if (scanToEnd === true) { + while (eos() !== true && (code = advance())) { + if (code === CHAR_BACKWARD_SLASH) { + backslashes = token.backslashes = true; + code = advance(); + continue; + } + + if (code === CHAR_RIGHT_PARENTHESES) { + isGlob = token.isGlob = true; + finished = true; + break; + } + } + continue; + } + break; + } + } + + if (code === CHAR_ASTERISK) { + if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true; + isGlob = token.isGlob = true; + finished = true; + + if (scanToEnd === true) { + continue; + } + break; + } + + if (code === CHAR_QUESTION_MARK) { + isGlob = token.isGlob = true; + finished = true; + + if (scanToEnd === true) { + continue; + } + break; + } + + if (code === CHAR_LEFT_SQUARE_BRACKET) { + while (eos() !== true && (next = advance())) { + if (next === CHAR_BACKWARD_SLASH) { + backslashes = token.backslashes = true; + advance(); + continue; + } + + if (next === CHAR_RIGHT_SQUARE_BRACKET) { + isBracket = token.isBracket = true; + isGlob = token.isGlob = true; + finished = true; + break; + } + } + + if (scanToEnd === true) { + continue; + } + + break; + } + + if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) { + negated = token.negated = true; + start++; + continue; + } + + if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) { + isGlob = token.isGlob = true; + + if (scanToEnd === true) { + while (eos() !== true && (code = advance())) { + if (code === CHAR_LEFT_PARENTHESES) { + backslashes = token.backslashes = true; + code = advance(); + continue; + } + + if (code === CHAR_RIGHT_PARENTHESES) { + finished = true; + break; + } + } + continue; + } + break; + } + + if (isGlob === true) { + finished = true; + + if (scanToEnd === true) { + continue; + } + + break; + } + } + + if (opts.noext === true) { + isExtglob = false; + isGlob = false; + } + + let base = str; + let prefix = ''; + let glob = ''; + + if (start > 0) { + prefix = str.slice(0, start); + str = str.slice(start); + lastIndex -= start; + } + + if (base && isGlob === true && lastIndex > 0) { + base = str.slice(0, lastIndex); + glob = str.slice(lastIndex); + } else if (isGlob === true) { + base = ''; + glob = str; + } else { + base = str; + } + + if (base && base !== '' && base !== '/' && base !== str) { + if (isPathSeparator(base.charCodeAt(base.length - 1))) { + base = base.slice(0, -1); + } + } + + if (opts.unescape === true) { + if (glob) glob = utils.removeBackslashes(glob); + + if (base && backslashes === true) { + base = utils.removeBackslashes(base); + } + } + + const state = { + prefix, + input, + start, + base, + glob, + isBrace, + isBracket, + isGlob, + isExtglob, + isGlobstar, + negated, + negatedExtglob + }; + + if (opts.tokens === true) { + state.maxDepth = 0; + if (!isPathSeparator(code)) { + tokens.push(token); + } + state.tokens = tokens; + } + + if (opts.parts === true || opts.tokens === true) { + let prevIndex; + + for (let idx = 0; idx < slashes.length; idx++) { + const n = prevIndex ? prevIndex + 1 : start; + const i = slashes[idx]; + const value = input.slice(n, i); + if (opts.tokens) { + if (idx === 0 && start !== 0) { + tokens[idx].isPrefix = true; + tokens[idx].value = prefix; + } else { + tokens[idx].value = value; + } + depth(tokens[idx]); + state.maxDepth += tokens[idx].depth; + } + if (idx !== 0 || value !== '') { + parts.push(value); + } + prevIndex = i; + } + + if (prevIndex && prevIndex + 1 < input.length) { + const value = input.slice(prevIndex + 1); + parts.push(value); + + if (opts.tokens) { + tokens[tokens.length - 1].value = value; + depth(tokens[tokens.length - 1]); + state.maxDepth += tokens[tokens.length - 1].depth; + } + } + + state.slashes = slashes; + state.parts = parts; + } + + return state; +}; + +module.exports = scan; diff --git a/frontend/node_modules/picomatch/lib/utils.js b/frontend/node_modules/picomatch/lib/utils.js new file mode 100644 index 0000000..9c97cae --- /dev/null +++ b/frontend/node_modules/picomatch/lib/utils.js @@ -0,0 +1,72 @@ +/*global navigator*/ +'use strict'; + +const { + REGEX_BACKSLASH, + REGEX_REMOVE_BACKSLASH, + REGEX_SPECIAL_CHARS, + REGEX_SPECIAL_CHARS_GLOBAL +} = require('./constants'); + +exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val); +exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str); +exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str); +exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1'); +exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/'); + +exports.isWindows = () => { + if (typeof navigator !== 'undefined' && navigator.platform) { + const platform = navigator.platform.toLowerCase(); + return platform === 'win32' || platform === 'windows'; + } + + if (typeof process !== 'undefined' && process.platform) { + return process.platform === 'win32'; + } + + return false; +}; + +exports.removeBackslashes = str => { + return str.replace(REGEX_REMOVE_BACKSLASH, match => { + return match === '\\' ? '' : match; + }); +}; + +exports.escapeLast = (input, char, lastIdx) => { + const idx = input.lastIndexOf(char, lastIdx); + if (idx === -1) return input; + if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1); + return `${input.slice(0, idx)}\\${input.slice(idx)}`; +}; + +exports.removePrefix = (input, state = {}) => { + let output = input; + if (output.startsWith('./')) { + output = output.slice(2); + state.prefix = './'; + } + return output; +}; + +exports.wrapOutput = (input, state = {}, options = {}) => { + const prepend = options.contains ? '' : '^'; + const append = options.contains ? '' : '$'; + + let output = `${prepend}(?:${input})${append}`; + if (state.negated === true) { + output = `(?:^(?!${output}).*$)`; + } + return output; +}; + +exports.basename = (path, { windows } = {}) => { + const segs = path.split(windows ? /[\\/]/ : '/'); + const last = segs[segs.length - 1]; + + if (last === '') { + return segs[segs.length - 2]; + } + + return last; +}; diff --git a/frontend/node_modules/picomatch/package.json b/frontend/node_modules/picomatch/package.json new file mode 100644 index 0000000..c8ebbae --- /dev/null +++ b/frontend/node_modules/picomatch/package.json @@ -0,0 +1,83 @@ +{ + "name": "picomatch", + "description": "Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.", + "version": "4.0.5", + "homepage": "https://github.com/micromatch/picomatch", + "author": "Jon Schlinkert (https://github.com/jonschlinkert)", + "funding": "https://github.com/sponsors/jonschlinkert", + "repository": "micromatch/picomatch", + "bugs": { + "url": "https://github.com/micromatch/picomatch/issues" + }, + "license": "MIT", + "files": [ + "index.js", + "posix.js", + "lib" + ], + "sideEffects": false, + "main": "index.js", + "engines": { + "node": ">=12" + }, + "scripts": { + "lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .", + "mocha": "mocha --reporter dot", + "test": "npm run lint && npm run mocha", + "test:ci": "npm run test:cover", + "test:cover": "nyc npm run mocha" + }, + "devDependencies": { + "eslint": "^8.57.0", + "fill-range": "^7.0.1", + "gulp-format-md": "^2.0.0", + "mocha": "^10.4.0", + "nyc": "^15.1.0" + }, + "keywords": [ + "glob", + "match", + "picomatch" + ], + "nyc": { + "reporter": [ + "html", + "lcov", + "text-summary", + "cobertura" + ] + }, + "verb": { + "toc": { + "render": true, + "method": "preWrite", + "maxdepth": 3 + }, + "layout": "empty", + "tasks": [ + "readme" + ], + "plugins": [ + "gulp-format-md" + ], + "lint": { + "reflinks": true + }, + "related": { + "list": [ + "braces", + "micromatch" + ] + }, + "reflinks": [ + "braces", + "expand-brackets", + "extglob", + "fill-range", + "micromatch", + "minimatch", + "nanomatch", + "picomatch" + ] + } +} diff --git a/frontend/node_modules/picomatch/posix.js b/frontend/node_modules/picomatch/posix.js new file mode 100644 index 0000000..d2f2bc5 --- /dev/null +++ b/frontend/node_modules/picomatch/posix.js @@ -0,0 +1,3 @@ +'use strict'; + +module.exports = require('./lib/picomatch'); diff --git a/frontend/node_modules/postcss/LICENSE b/frontend/node_modules/postcss/LICENSE new file mode 100644 index 0000000..c2314d5 --- /dev/null +++ b/frontend/node_modules/postcss/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright 2013 Andrey Sitnik + +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/frontend/node_modules/postcss/README.md b/frontend/node_modules/postcss/README.md new file mode 100644 index 0000000..2df9301 --- /dev/null +++ b/frontend/node_modules/postcss/README.md @@ -0,0 +1,25 @@ +# PostCSS + +Philosopher’s stone, logo of PostCSS + +PostCSS is a tool for transforming styles with JS plugins. +These plugins can lint your CSS, support variables and mixins, +transpile future CSS syntax, inline images, and more. + +PostCSS is used by industry leaders including Wikipedia, Twitter, Alibaba, +and JetBrains. The [Autoprefixer] and [Stylelint] PostCSS plugins are some of the most popular CSS tools. + +--- + +  Built by +Evil Martians, go-to agency for developer tools. + +--- + +[Abstract Syntax Tree]: https://en.wikipedia.org/wiki/Abstract_syntax_tree +[Evil Martians]: https://evilmartians.com/?utm_source=postcss +[Autoprefixer]: https://github.com/postcss/autoprefixer +[Stylelint]: https://stylelint.io/ +[plugins]: https://github.com/postcss/postcss#plugins diff --git a/frontend/node_modules/postcss/lib/at-rule.d.ts b/frontend/node_modules/postcss/lib/at-rule.d.ts new file mode 100644 index 0000000..703e399 --- /dev/null +++ b/frontend/node_modules/postcss/lib/at-rule.d.ts @@ -0,0 +1,139 @@ +import Container, { + ContainerProps, + ContainerWithChildren +} from './container.js' + +declare namespace AtRule { + export interface AtRuleRaws extends Record { + /** + * The space symbols after the last child of the node to the end of the node. + */ + after?: string + + /** + * The space between the at-rule name and its parameters. + */ + afterName?: string + + /** + * The space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + */ + before?: string + + /** + * The symbols between the last parameter and `{` for rules. + */ + between?: string + + /** + * The rule’s selector with comments. + */ + params?: { + raw: string + value: string + } + + /** + * Contains `true` if the last child has an (optional) semicolon. + */ + semicolon?: boolean + } + + export interface AtRuleProps extends ContainerProps { + /** Name of the at-rule. */ + name: string + /** Parameters following the name of the at-rule. */ + params?: number | string + /** Information used to generate byte-to-byte equal node string as it was in the origin input. */ + raws?: AtRuleRaws + } + + export { AtRule_ as default } +} + +/** + * Represents an at-rule. + * + * ```js + * Once (root, { AtRule }) { + * let media = new AtRule({ name: 'media', params: 'print' }) + * media.append(…) + * root.append(media) + * } + * ``` + * + * If it’s followed in the CSS by a `{}` block, this node will have + * a nodes property representing its children. + * + * ```js + * const root = postcss.parse('@charset "UTF-8"; @media print {}') + * + * const charset = root.first + * charset.type //=> 'atrule' + * charset.nodes //=> undefined + * + * const media = root.last + * media.nodes //=> [] + * ``` + */ +declare class AtRule_ extends Container { + /** + * An array containing the layer’s children. + * + * ```js + * const root = postcss.parse('@layer example { a { color: black } }') + * const layer = root.first + * layer.nodes.length //=> 1 + * layer.nodes[0].selector //=> 'a' + * ``` + * + * Can be `undefinded` if the at-rule has no body. + * + * ```js + * const root = postcss.parse('@layer a, b, c;') + * const layer = root.first + * layer.nodes //=> undefined + * ``` + */ + nodes: Container['nodes'] | undefined + parent: ContainerWithChildren | undefined + + raws: AtRule.AtRuleRaws + type: 'atrule' + /** + * The at-rule’s name immediately follows the `@`. + * + * ```js + * const root = postcss.parse('@media print {}') + * const media = root.first + * media.name //=> 'media' + * ``` + */ + get name(): string + set name(value: string) + + /** + * The at-rule’s parameters, the values that follow the at-rule’s name + * but precede any `{}` block. + * + * ```js + * const root = postcss.parse('@media print, screen {}') + * const media = root.first + * media.params //=> 'print, screen' + * ``` + */ + get params(): string + + set params(value: string) + + constructor(defaults?: AtRule.AtRuleProps) + assign(overrides: AtRule.AtRuleProps | object): this + clone(overrides?: Partial): this + cloneAfter(overrides?: Partial): this + cloneBefore(overrides?: Partial): this +} + +declare class AtRule extends AtRule_ {} + +export = AtRule diff --git a/frontend/node_modules/postcss/lib/at-rule.js b/frontend/node_modules/postcss/lib/at-rule.js new file mode 100644 index 0000000..9486447 --- /dev/null +++ b/frontend/node_modules/postcss/lib/at-rule.js @@ -0,0 +1,25 @@ +'use strict' + +let Container = require('./container') + +class AtRule extends Container { + constructor(defaults) { + super(defaults) + this.type = 'atrule' + } + + append(...children) { + if (!this.proxyOf.nodes) this.nodes = [] + return super.append(...children) + } + + prepend(...children) { + if (!this.proxyOf.nodes) this.nodes = [] + return super.prepend(...children) + } +} + +module.exports = AtRule +AtRule.default = AtRule + +Container.registerAtRule(AtRule) diff --git a/frontend/node_modules/postcss/lib/comment.d.ts b/frontend/node_modules/postcss/lib/comment.d.ts new file mode 100644 index 0000000..f764109 --- /dev/null +++ b/frontend/node_modules/postcss/lib/comment.d.ts @@ -0,0 +1,67 @@ +import Container from './container.js' +import Node, { NodeProps } from './node.js' + +declare namespace Comment { + export interface CommentRaws extends Record { + /** + * The space symbols before the node. + */ + before?: string + + /** + * The space symbols between `/*` and the comment’s text. + */ + left?: string + + /** + * The space symbols between the comment’s text. + */ + right?: string + } + + export interface CommentProps extends NodeProps { + /** Information used to generate byte-to-byte equal node string as it was in the origin input. */ + raws?: CommentRaws + /** Content of the comment. */ + text: string + } + + export { Comment_ as default } +} + +/** + * It represents a class that handles + * [CSS comments](https://developer.mozilla.org/en-US/docs/Web/CSS/Comments) + * + * ```js + * Once (root, { Comment }) { + * const note = new Comment({ text: 'Note: …' }) + * root.append(note) + * } + * ``` + * + * Remember that CSS comments inside selectors, at-rule parameters, + * or declaration values will be stored in the `raws` properties + * explained above. + */ +declare class Comment_ extends Node { + parent: Container | undefined + raws: Comment.CommentRaws + type: 'comment' + /** + * The comment's text. + */ + get text(): string + + set text(value: string) + + constructor(defaults?: Comment.CommentProps) + assign(overrides: Comment.CommentProps | object): this + clone(overrides?: Partial): this + cloneAfter(overrides?: Partial): this + cloneBefore(overrides?: Partial): this +} + +declare class Comment extends Comment_ {} + +export = Comment diff --git a/frontend/node_modules/postcss/lib/comment.js b/frontend/node_modules/postcss/lib/comment.js new file mode 100644 index 0000000..c566506 --- /dev/null +++ b/frontend/node_modules/postcss/lib/comment.js @@ -0,0 +1,13 @@ +'use strict' + +let Node = require('./node') + +class Comment extends Node { + constructor(defaults) { + super(defaults) + this.type = 'comment' + } +} + +module.exports = Comment +Comment.default = Comment diff --git a/frontend/node_modules/postcss/lib/container.d.ts b/frontend/node_modules/postcss/lib/container.d.ts new file mode 100644 index 0000000..82b24d0 --- /dev/null +++ b/frontend/node_modules/postcss/lib/container.d.ts @@ -0,0 +1,478 @@ +import AtRule from './at-rule.js' +import Comment from './comment.js' +import Declaration from './declaration.js' +import Node, { ChildNode, ChildProps, NodeProps } from './node.js' +import { Root } from './postcss.js' +import Rule from './rule.js' + +declare namespace Container { + export type ContainerWithChildren = { + nodes: Child[] + } & (AtRule | Root | Rule) + + export interface ValueOptions { + /** + * String that’s used to narrow down values and speed up the regexp search. + */ + fast?: string + + /** + * An array of property names. + */ + props?: readonly string[] + } + + export interface ContainerProps extends NodeProps { + nodes?: readonly (ChildProps | Node)[] + } + + /** + * All types that can be passed into container methods to create or add a new + * child node. + */ + export type NewChild = + | ChildProps + | Node + | readonly ChildProps[] + | readonly Node[] + | readonly string[] + | string + | undefined + + export { Container_ as default } +} + +/** + * The `Root`, `AtRule`, and `Rule` container nodes + * inherit some common methods to help work with their children. + * + * Note that all containers can store any content. If you write a rule inside + * a rule, PostCSS will parse it. + */ +declare abstract class Container_ extends Node { + /** + * An array containing the container’s children. + * + * ```js + * const root = postcss.parse('a { color: black }') + * root.nodes.length //=> 1 + * root.nodes[0].selector //=> 'a' + * root.nodes[0].nodes[0].prop //=> 'color' + * ``` + */ + nodes: Child[] | undefined + + /** + * The container’s first child. + * + * ```js + * rule.first === rules.nodes[0] + * ``` + */ + get first(): Child | undefined + + /** + * The container’s last child. + * + * ```js + * rule.last === rule.nodes[rule.nodes.length - 1] + * ``` + */ + get last(): Child | undefined + /** + * Inserts new nodes to the end of the container. + * + * ```js + * const decl1 = new Declaration({ prop: 'color', value: 'black' }) + * const decl2 = new Declaration({ prop: 'background-color', value: 'white' }) + * rule.append(decl1, decl2) + * + * root.append({ name: 'charset', params: '"UTF-8"' }) // at-rule + * root.append({ selector: 'a' }) // rule + * rule.append({ prop: 'color', value: 'black' }) // declaration + * rule.append({ text: 'Comment' }) // comment + * + * root.append('a {}') + * root.first.append('color: black; z-index: 1') + * ``` + * + * @param nodes New nodes. + * @return This node for methods chain. + */ + append(...nodes: Container.NewChild[]): this + assign(overrides: Container.ContainerProps | object): this + clone(overrides?: Partial): this + + cloneAfter(overrides?: Partial): this + + cloneBefore(overrides?: Partial): this + /** + * Iterates through the container’s immediate children, + * calling `callback` for each child. + * + * Returning `false` in the callback will break iteration. + * + * This method only iterates through the container’s immediate children. + * If you need to recursively iterate through all the container’s descendant + * nodes, use `Container#walk`. + * + * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe + * if you are mutating the array of child nodes during iteration. + * PostCSS will adjust the current index to match the mutations. + * + * ```js + * const root = postcss.parse('a { color: black; z-index: 1 }') + * const rule = root.first + * + * for (const decl of rule.nodes) { + * decl.cloneBefore({ prop: '-webkit-' + decl.prop }) + * // Cycle will be infinite, because cloneBefore moves the current node + * // to the next index + * } + * + * rule.each(decl => { + * decl.cloneBefore({ prop: '-webkit-' + decl.prop }) + * // Will be executed only for color and z-index + * }) + * ``` + * + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + each( + callback: (node: Child, index: number) => false | void + ): false | undefined + + /** + * Returns `true` if callback returns `true` + * for all of the container’s children. + * + * ```js + * const noPrefixes = rule.every(i => i.prop[0] !== '-') + * ``` + * + * @param condition Iterator returns true or false. + * @return Is every child pass condition. + */ + every( + condition: (node: Child, index: number, nodes: Child[]) => boolean + ): boolean + /** + * Returns a `child`’s index within the `Container#nodes` array. + * + * ```js + * rule.index( rule.nodes[2] ) //=> 2 + * ``` + * + * @param child Child of the current container. + * @return Child index. + */ + index(child: Child | number): number + + /** + * Insert new node after old node within the container. + * + * @param oldNode Child or child’s index. + * @param newNode New node. + * @return This node for methods chain. + */ + insertAfter(oldNode: Child | number, newNode: Container.NewChild): this + + /** + * Traverses the container’s descendant nodes, calling callback + * for each comment node. + * + * Like `Container#each`, this method is safe + * to use if you are mutating arrays during iteration. + * + * ```js + * root.walkComments(comment => { + * comment.remove() + * }) + * ``` + * + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + + /** + * Insert new node before old node within the container. + * + * ```js + * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop })) + * ``` + * + * @param oldNode Child or child’s index. + * @param newNode New node. + * @return This node for methods chain. + */ + insertBefore(oldNode: Child | number, newNode: Container.NewChild): this + /** + * Inserts new nodes to the start of the container. + * + * ```js + * const decl1 = new Declaration({ prop: 'color', value: 'black' }) + * const decl2 = new Declaration({ prop: 'background-color', value: 'white' }) + * rule.prepend(decl1, decl2) + * + * root.append({ name: 'charset', params: '"UTF-8"' }) // at-rule + * root.append({ selector: 'a' }) // rule + * rule.append({ prop: 'color', value: 'black' }) // declaration + * rule.append({ text: 'Comment' }) // comment + * + * root.append('a {}') + * root.first.append('color: black; z-index: 1') + * ``` + * + * @param nodes New nodes. + * @return This node for methods chain. + */ + prepend(...nodes: Container.NewChild[]): this + + /** + * Add child to the end of the node. + * + * ```js + * rule.push(new Declaration({ prop: 'color', value: 'black' })) + * ``` + * + * @param child New node. + * @return This node for methods chain. + */ + push(child: Child): this + + /** + * Removes all children from the container + * and cleans their parent properties. + * + * ```js + * rule.removeAll() + * rule.nodes.length //=> 0 + * ``` + * + * @return This node for methods chain. + */ + removeAll(): this + + /** + * Removes node from the container and cleans the parent properties + * from the node and its children. + * + * ```js + * rule.nodes.length //=> 5 + * rule.removeChild(decl) + * rule.nodes.length //=> 4 + * decl.parent //=> undefined + * ``` + * + * @param child Child or child’s index. + * @return This node for methods chain. + */ + removeChild(child: Child | number): this + + replaceValues( + pattern: RegExp | string, + replaced: { (substring: string, ...args: any[]): string } | string + ): this + /** + * Passes all declaration values within the container that match pattern + * through callback, replacing those values with the returned result + * of callback. + * + * This method is useful if you are using a custom unit or function + * and need to iterate through all values. + * + * ```js + * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => { + * return 15 * parseInt(string) + 'px' + * }) + * ``` + * + * @param pattern Replace pattern. + * @param {object} options Options to speed up the search. + * @param replaced String to replace pattern or callback + * that returns a new value. The callback + * will receive the same arguments + * as those passed to a function parameter + * of `String#replace`. + * @return This node for methods chain. + */ + replaceValues( + pattern: RegExp | string, + options: Container.ValueOptions, + replaced: { (substring: string, ...args: any[]): string } | string + ): this + + /** + * Returns `true` if callback returns `true` for (at least) one + * of the container’s children. + * + * ```js + * const hasPrefix = rule.some(i => i.prop[0] === '-') + * ``` + * + * @param condition Iterator returns true or false. + * @return Is some child pass condition. + */ + some( + condition: (node: Child, index: number, nodes: Child[]) => boolean + ): boolean + + /** + * Traverses the container’s descendant nodes, calling callback + * for each node. + * + * Like container.each(), this method is safe to use + * if you are mutating arrays during iteration. + * + * If you only need to iterate through the container’s immediate children, + * use `Container#each`. + * + * ```js + * root.walk(node => { + * // Traverses all descendant nodes. + * }) + * ``` + * + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + walk( + callback: (node: ChildNode, index: number) => false | void + ): false | undefined + + /** + * Traverses the container’s descendant nodes, calling callback + * for each at-rule node. + * + * If you pass a filter, iteration will only happen over at-rules + * that have matching names. + * + * Like `Container#each`, this method is safe + * to use if you are mutating arrays during iteration. + * + * ```js + * root.walkAtRules(rule => { + * if (isOld(rule.name)) rule.remove() + * }) + * + * let first = false + * root.walkAtRules('charset', rule => { + * if (!first) { + * first = true + * } else { + * rule.remove() + * } + * }) + * ``` + * + * @param name String or regular expression to filter at-rules by name. + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + walkAtRules( + nameFilter: RegExp | string, + callback: (atRule: AtRule, index: number) => false | void + ): false | undefined + walkAtRules( + callback: (atRule: AtRule, index: number) => false | void + ): false | undefined + + walkComments( + callback: (comment: Comment, indexed: number) => false | void + ): false | undefined + walkComments( + callback: (comment: Comment, indexed: number) => false | void + ): false | undefined + + /** + * Traverses the container’s descendant nodes, calling callback + * for each declaration node. + * + * If you pass a filter, iteration will only happen over declarations + * with matching properties. + * + * ```js + * root.walkDecls(decl => { + * checkPropertySupport(decl.prop) + * }) + * + * root.walkDecls('border-radius', decl => { + * decl.remove() + * }) + * + * root.walkDecls(/^background/, decl => { + * decl.value = takeFirstColorFromGradient(decl.value) + * }) + * ``` + * + * Like `Container#each`, this method is safe + * to use if you are mutating arrays during iteration. + * + * @param prop String or regular expression to filter declarations + * by property name. + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + walkDecls( + propFilter: RegExp | string, + callback: (decl: Declaration, index: number) => false | void + ): false | undefined + walkDecls( + callback: (decl: Declaration, index: number) => false | void + ): false | undefined + /** + * Traverses the container’s descendant nodes, calling callback + * for each rule node. + * + * If you pass a filter, iteration will only happen over rules + * with matching selectors. + * + * Like `Container#each`, this method is safe + * to use if you are mutating arrays during iteration. + * + * ```js + * const selectors = [] + * root.walkRules(rule => { + * selectors.push(rule.selector) + * }) + * console.log(`Your CSS uses ${ selectors.length } selectors`) + * ``` + * + * @param selector String or regular expression to filter rules by selector. + * @param callback Iterator receives each node and index. + * @return Returns `false` if iteration was broke. + */ + walkRules( + selectorFilter: RegExp | string, + callback: (rule: Rule, index: number) => false | void + ): false | undefined + walkRules( + callback: (rule: Rule, index: number) => false | void + ): false | undefined + /** + * An internal method that converts a {@link NewChild} into a list of actual + * child nodes that can then be added to this container. + * + * This ensures that the nodes' parent is set to this container, that they use + * the correct prototype chain, and that they're marked as dirty. + * + * @param mnodes The new node or nodes to add. + * @param sample A node from whose raws the new node's `before` raw should be + * taken. + * @param type This should be set to `'prepend'` if the new nodes will be + * inserted at the beginning of the container. + * @hidden + */ + protected normalize( + nodes: Container.NewChild, + sample: Node | undefined, + type?: 'prepend' | false + ): Child[] +} + +declare class Container< + Child extends Node = ChildNode +> extends Container_ {} + +export = Container diff --git a/frontend/node_modules/postcss/lib/container.js b/frontend/node_modules/postcss/lib/container.js new file mode 100644 index 0000000..edb07cc --- /dev/null +++ b/frontend/node_modules/postcss/lib/container.js @@ -0,0 +1,447 @@ +'use strict' + +let Comment = require('./comment') +let Declaration = require('./declaration') +let Node = require('./node') +let { isClean, my } = require('./symbols') + +let AtRule, parse, Root, Rule + +function cleanSource(nodes) { + return nodes.map(i => { + if (i.nodes) i.nodes = cleanSource(i.nodes) + delete i.source + return i + }) +} + +function markTreeDirty(node) { + node[isClean] = false + if (node.proxyOf.nodes) { + for (let i of node.proxyOf.nodes) { + markTreeDirty(i) + } + } +} + +class Container extends Node { + get first() { + if (!this.proxyOf.nodes) return undefined + return this.proxyOf.nodes[0] + } + + get last() { + if (!this.proxyOf.nodes) return undefined + return this.proxyOf.nodes[this.proxyOf.nodes.length - 1] + } + + append(...children) { + for (let child of children) { + let nodes = this.normalize(child, this.last) + for (let node of nodes) this.proxyOf.nodes.push(node) + } + + this.markDirty() + + return this + } + + cleanRaws(keepBetween) { + super.cleanRaws(keepBetween) + if (this.nodes) { + for (let node of this.nodes) node.cleanRaws(keepBetween) + } + } + + each(callback) { + if (!this.proxyOf.nodes) return undefined + let iterator = this.getIterator() + + let index, result + while (this.indexes[iterator] < this.proxyOf.nodes.length) { + index = this.indexes[iterator] + result = callback(this.proxyOf.nodes[index], index) + if (result === false) break + + this.indexes[iterator] += 1 + } + + delete this.indexes[iterator] + return result + } + + every(condition) { + return this.nodes.every(condition) + } + + getIterator() { + if (!this.lastEach) this.lastEach = 0 + if (!this.indexes) this.indexes = {} + + this.lastEach += 1 + let iterator = this.lastEach + this.indexes[iterator] = 0 + + return iterator + } + + getProxyProcessor() { + return { + get(node, prop) { + if (prop === 'proxyOf') { + return node + } else if (!node[prop]) { + return node[prop] + } else if ( + prop === 'each' || + (typeof prop === 'string' && prop.startsWith('walk')) + ) { + return (...args) => { + return node[prop]( + ...args.map(i => { + if (typeof i === 'function') { + return (child, index) => i(child.toProxy(), index) + } else { + return i + } + }) + ) + } + } else if (prop === 'every' || prop === 'some') { + return cb => { + return node[prop]((child, ...other) => + cb(child.toProxy(), ...other) + ) + } + } else if (prop === 'root') { + return () => node.root().toProxy() + } else if (prop === 'nodes') { + return node.nodes.map(i => i.toProxy()) + } else if (prop === 'first' || prop === 'last') { + return node[prop].toProxy() + } else { + return node[prop] + } + }, + + set(node, prop, value) { + if (node[prop] === value) return true + node[prop] = value + if (prop === 'name' || prop === 'params' || prop === 'selector') { + node.markDirty() + } + return true + } + } + } + + index(child) { + if (typeof child === 'number') return child + if (child.proxyOf) child = child.proxyOf + return this.proxyOf.nodes.indexOf(child) + } + + insertAfter(exist, add) { + let existIndex = this.index(exist) + let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse() + existIndex = this.index(exist) + for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node) + + let index + for (let id in this.indexes) { + index = this.indexes[id] + if (existIndex < index) { + this.indexes[id] = index + nodes.length + } + } + + this.markDirty() + + return this + } + + insertBefore(exist, add) { + let existIndex = this.index(exist) + let type = existIndex === 0 ? 'prepend' : false + let nodes = this.normalize( + add, + this.proxyOf.nodes[existIndex], + type + ).reverse() + existIndex = this.index(exist) + for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node) + + let index + for (let id in this.indexes) { + index = this.indexes[id] + if (existIndex <= index) { + this.indexes[id] = index + nodes.length + } + } + + this.markDirty() + + return this + } + + normalize(nodes, sample) { + if (typeof nodes === 'string') { + nodes = cleanSource(parse(nodes).nodes) + } else if (typeof nodes === 'undefined') { + nodes = [] + } else if (Array.isArray(nodes)) { + nodes = nodes.slice(0) + for (let i of nodes) { + if (i.parent) i.parent.removeChild(i, 'ignore') + } + } else if (nodes.type === 'root' && this.type !== 'document') { + nodes = nodes.nodes.slice(0) + for (let i of nodes) { + if (i.parent) i.parent.removeChild(i, 'ignore') + } + } else if (nodes.type) { + nodes = [nodes] + } else if (nodes.prop) { + if (typeof nodes.value === 'undefined') { + throw new Error('Value field is missed in node creation') + } else if (typeof nodes.value !== 'string') { + nodes.value = String(nodes.value) + } + nodes = [new Declaration(nodes)] + } else if (nodes.selector || nodes.selectors) { + nodes = [new Rule(nodes)] + } else if (nodes.name) { + nodes = [new AtRule(nodes)] + } else if (nodes.text) { + nodes = [new Comment(nodes)] + } else { + throw new Error('Unknown node type in node creation') + } + + let processed = nodes.map(i => { + /* c8 ignore next */ + if (!i[my]) Container.rebuild(i) + i = i.proxyOf + if (i.parent) i.parent.removeChild(i) + if (i[isClean]) markTreeDirty(i) + + if (!i.raws) i.raws = {} + if (typeof i.raws.before === 'undefined') { + if (sample && typeof sample.raws.before !== 'undefined') { + i.raws.before = sample.raws.before.replace(/\S/g, '') + } + } + i.parent = this.proxyOf + return i + }) + + return processed + } + + prepend(...children) { + children = children.reverse() + for (let child of children) { + let nodes = this.normalize(child, this.first, 'prepend').reverse() + for (let node of nodes) this.proxyOf.nodes.unshift(node) + for (let id in this.indexes) { + this.indexes[id] = this.indexes[id] + nodes.length + } + } + + this.markDirty() + + return this + } + + push(child) { + child.parent = this + this.proxyOf.nodes.push(child) + return this + } + + removeAll() { + for (let node of this.proxyOf.nodes) node.parent = undefined + this.proxyOf.nodes = [] + + this.markDirty() + + return this + } + + removeChild(child) { + child = this.index(child) + this.proxyOf.nodes[child].parent = undefined + this.proxyOf.nodes.splice(child, 1) + + let index + for (let id in this.indexes) { + index = this.indexes[id] + if (index >= child) { + this.indexes[id] = index - 1 + } + } + + this.markDirty() + + return this + } + + replaceValues(pattern, opts, callback) { + if (!callback) { + callback = opts + opts = {} + } + + this.walkDecls(decl => { + if (opts.props && !opts.props.includes(decl.prop)) return + if (opts.fast && !decl.value.includes(opts.fast)) return + + decl.value = decl.value.replace(pattern, callback) + }) + + this.markDirty() + + return this + } + + some(condition) { + return this.nodes.some(condition) + } + + walk(callback) { + return this.each((child, i) => { + let result + try { + result = callback(child, i) + } catch (e) { + throw child.addToError(e) + } + if (result !== false && child.walk) { + result = child.walk(callback) + } + + return result + }) + } + + walkAtRules(name, callback) { + if (!callback) { + callback = name + return this.walk((child, i) => { + if (child.type === 'atrule') { + return callback(child, i) + } + }) + } + if (name instanceof RegExp) { + return this.walk((child, i) => { + if (child.type === 'atrule' && name.test(child.name)) { + return callback(child, i) + } + }) + } + return this.walk((child, i) => { + if (child.type === 'atrule' && child.name === name) { + return callback(child, i) + } + }) + } + + walkComments(callback) { + return this.walk((child, i) => { + if (child.type === 'comment') { + return callback(child, i) + } + }) + } + + walkDecls(prop, callback) { + if (!callback) { + callback = prop + return this.walk((child, i) => { + if (child.type === 'decl') { + return callback(child, i) + } + }) + } + if (prop instanceof RegExp) { + return this.walk((child, i) => { + if (child.type === 'decl' && prop.test(child.prop)) { + return callback(child, i) + } + }) + } + return this.walk((child, i) => { + if (child.type === 'decl' && child.prop === prop) { + return callback(child, i) + } + }) + } + + walkRules(selector, callback) { + if (!callback) { + callback = selector + + return this.walk((child, i) => { + if (child.type === 'rule') { + return callback(child, i) + } + }) + } + if (selector instanceof RegExp) { + return this.walk((child, i) => { + if (child.type === 'rule' && selector.test(child.selector)) { + return callback(child, i) + } + }) + } + return this.walk((child, i) => { + if (child.type === 'rule' && child.selector === selector) { + return callback(child, i) + } + }) + } +} + +Container.registerParse = dependant => { + parse = dependant +} + +Container.registerRule = dependant => { + Rule = dependant +} + +Container.registerAtRule = dependant => { + AtRule = dependant +} + +Container.registerRoot = dependant => { + Root = dependant +} + +module.exports = Container +Container.default = Container + +/* c8 ignore start */ +Container.rebuild = node => { + if (node.type === 'atrule') { + Object.setPrototypeOf(node, AtRule.prototype) + } else if (node.type === 'rule') { + Object.setPrototypeOf(node, Rule.prototype) + } else if (node.type === 'decl') { + Object.setPrototypeOf(node, Declaration.prototype) + } else if (node.type === 'comment') { + Object.setPrototypeOf(node, Comment.prototype) + } else if (node.type === 'root') { + Object.setPrototypeOf(node, Root.prototype) + } + + node[my] = true + + if (node.nodes) { + node.nodes.forEach(child => { + Container.rebuild(child) + }) + } +} +/* c8 ignore stop */ diff --git a/frontend/node_modules/postcss/lib/css-syntax-error.d.ts b/frontend/node_modules/postcss/lib/css-syntax-error.d.ts new file mode 100644 index 0000000..03d9ed1 --- /dev/null +++ b/frontend/node_modules/postcss/lib/css-syntax-error.d.ts @@ -0,0 +1,247 @@ +import { FilePosition } from './input.js' + +declare namespace CssSyntaxError { + /** + * A position that is part of a range. + */ + export interface RangePosition { + /** + * The column number in the input. + */ + column: number + + /** + * The line number in the input. + */ + line: number + } + + export { CssSyntaxError_ as default } +} + +/** + * The CSS parser throws this error for broken CSS. + * + * Custom parsers can throw this error for broken custom syntax using + * the `Node#error` method. + * + * PostCSS will use the input source map to detect the original error location. + * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS, + * PostCSS will show the original position in the Sass file. + * + * If you need the position in the PostCSS input + * (e.g., to debug the previous compiler), use `error.input.file`. + * + * ```js + * // Raising error from plugin + * throw node.error('Unknown variable', { plugin: 'postcss-vars' }) + * ``` + * + * ```js + * // Catching and checking syntax error + * try { + * postcss.parse('a{') + * } catch (error) { + * if (error.name === 'CssSyntaxError') { + * error //=> CssSyntaxError + * } + * } + * ``` + */ +declare class CssSyntaxError_ extends Error { + /** + * Source column of the error. + * + * ```js + * error.column //=> 1 + * error.input.column //=> 4 + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.column`. + */ + column?: number + + /** + * Source column of the error's end, exclusive. Provided if the error pertains + * to a range. + * + * ```js + * error.endColumn //=> 1 + * error.input.endColumn //=> 4 + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.endColumn`. + */ + endColumn?: number + + /** + * Source line of the error's end, exclusive. Provided if the error pertains + * to a range. + * + * ```js + * error.endLine //=> 3 + * error.input.endLine //=> 4 + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.endLine`. + */ + endLine?: number + + /** + * Absolute path to the broken file. + * + * ```js + * error.file //=> 'a.sass' + * error.input.file //=> 'a.css' + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.file`. + */ + file?: string + + /** + * Input object with PostCSS internal information + * about input file. If input has source map + * from previous tool, PostCSS will use origin + * (for example, Sass) source. You can use this + * object to get PostCSS input source. + * + * ```js + * error.input.file //=> 'a.css' + * error.file //=> 'a.sass' + * ``` + */ + input?: FilePosition + + /** + * Source line of the error. + * + * ```js + * error.line //=> 2 + * error.input.line //=> 4 + * ``` + * + * PostCSS will use the input source map to detect the original location. + * If you need the position in the PostCSS input, use `error.input.line`. + */ + line?: number + + /** + * Full error text in the GNU error format + * with plugin, file, line and column. + * + * ```js + * error.message //=> 'a.css:1:1: Unclosed block' + * ``` + */ + message: string + + /** + * Always equal to `'CssSyntaxError'`. You should always check error type + * by `error.name === 'CssSyntaxError'` + * instead of `error instanceof CssSyntaxError`, + * because npm could have several PostCSS versions. + * + * ```js + * if (error.name === 'CssSyntaxError') { + * error //=> CssSyntaxError + * } + * ``` + */ + name: 'CssSyntaxError' + + /** + * Plugin name, if error came from plugin. + * + * ```js + * error.plugin //=> 'postcss-vars' + * ``` + */ + plugin?: string + + /** + * Error message. + * + * ```js + * error.message //=> 'Unclosed block' + * ``` + */ + reason: string + + /** + * Source code of the broken file. + * + * ```js + * error.source //=> 'a { b {} }' + * error.input.source //=> 'a b { }' + * ``` + */ + source?: string + + stack: string + + /** + * Instantiates a CSS syntax error. Can be instantiated for a single position + * or for a range. + * @param message Error message. + * @param lineOrStartPos If for a single position, the line number, or if for + * a range, the inclusive start position of the error. + * @param columnOrEndPos If for a single position, the column number, or if for + * a range, the exclusive end position of the error. + * @param source Source code of the broken file. + * @param file Absolute path to the broken file. + * @param plugin PostCSS plugin name, if error came from plugin. + */ + constructor( + message: string, + lineOrStartPos?: CssSyntaxError.RangePosition | number, + columnOrEndPos?: CssSyntaxError.RangePosition | number, + source?: string, + file?: string, + plugin?: string + ) + + /** + * Returns a few lines of CSS source that caused the error. + * + * If the CSS has an input source map without `sourceContent`, + * this method will return an empty string. + * + * ```js + * error.showSourceCode() //=> " 4 | } + * // 5 | a { + * // > 6 | bad + * // | ^ + * // 7 | } + * // 8 | b {" + * ``` + * + * @param color Whether arrow will be colored red by terminal + * color codes. By default, PostCSS will detect + * color support by `process.stdout.isTTY` + * and `process.env.NODE_DISABLE_COLORS`. + * @return Few lines of CSS source that caused the error. + */ + showSourceCode(color?: boolean): string + + /** + * Returns error position, message and source code of the broken part. + * + * ```js + * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block + * // > 1 | a { + * // | ^" + * ``` + * + * @return Error position, message and source code. + */ + toString(): string +} + +declare class CssSyntaxError extends CssSyntaxError_ {} + +export = CssSyntaxError diff --git a/frontend/node_modules/postcss/lib/css-syntax-error.js b/frontend/node_modules/postcss/lib/css-syntax-error.js new file mode 100644 index 0000000..275a4f6 --- /dev/null +++ b/frontend/node_modules/postcss/lib/css-syntax-error.js @@ -0,0 +1,133 @@ +'use strict' + +let pico = require('picocolors') + +let terminalHighlight = require('./terminal-highlight') + +class CssSyntaxError extends Error { + constructor(message, line, column, source, file, plugin) { + super(message) + this.name = 'CssSyntaxError' + this.reason = message + + if (file) { + this.file = file + } + if (source) { + this.source = source + } + if (plugin) { + this.plugin = plugin + } + if (typeof line !== 'undefined' && typeof column !== 'undefined') { + if (typeof line === 'number') { + this.line = line + this.column = column + } else { + this.line = line.line + this.column = line.column + this.endLine = column.line + this.endColumn = column.column + } + } + + this.setMessage() + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, CssSyntaxError) + } + } + + setMessage() { + this.message = this.plugin ? this.plugin + ': ' : '' + this.message += this.file ? this.file : '' + if (typeof this.line !== 'undefined') { + this.message += ':' + this.line + ':' + this.column + } + this.message += ': ' + this.reason + } + + showSourceCode(color) { + if (!this.source) return '' + + let css = this.source + if (color == null) color = pico.isColorSupported + + let aside = text => text + let mark = text => text + let highlight = text => text + if (color) { + let { bold, gray, red } = pico.createColors(true) + mark = text => bold(red(text)) + aside = text => gray(text) + if (terminalHighlight) { + highlight = text => terminalHighlight(text) + } + } + + let lines = css.split(/\r?\n/) + let start = Math.max(this.line - 3, 0) + let end = Math.min(this.line + 2, lines.length) + let maxWidth = String(end).length + + return lines + .slice(start, end) + .map((line, index) => { + let number = start + 1 + index + let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ' + if (number === this.line) { + if (line.length > 160) { + let padding = 20 + let subLineStart = Math.max(0, this.column - padding) + let subLineEnd = Math.max( + this.column + padding, + this.endColumn + padding + ) + let subLine = line.slice(subLineStart, subLineEnd) + + let spacing = + aside(gutter.replace(/\d/g, ' ')) + + line + .slice(0, Math.min(this.column - 1, padding - 1)) + .replace(/[^\t]/g, ' ') + + return ( + mark('>') + + aside(gutter) + + highlight(subLine) + + '\n ' + + spacing + + mark('^') + ) + } + + let spacing = + aside(gutter.replace(/\d/g, ' ')) + + line.slice(0, this.column - 1).replace(/[^\t]/g, ' ') + + return ( + mark('>') + + aside(gutter) + + highlight(line) + + '\n ' + + spacing + + mark('^') + ) + } + + return ' ' + aside(gutter) + highlight(line) + }) + .join('\n') + } + + toString() { + let code = this.showSourceCode() + if (code) { + code = '\n\n' + code + '\n' + } + return this.name + ': ' + this.message + code + } +} + +module.exports = CssSyntaxError +CssSyntaxError.default = CssSyntaxError diff --git a/frontend/node_modules/postcss/lib/declaration.d.ts b/frontend/node_modules/postcss/lib/declaration.d.ts new file mode 100644 index 0000000..55dec7f --- /dev/null +++ b/frontend/node_modules/postcss/lib/declaration.d.ts @@ -0,0 +1,150 @@ +import { ContainerWithChildren } from './container.js' +import Node from './node.js' + +declare namespace Declaration { + export interface DeclarationRaws extends Record { + /** + * The space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + */ + before?: string + + /** + * The symbols between the property and value for declarations. + */ + between?: string + + /** + * The content of the important statement, if it is not just `!important`. + */ + important?: string + + /** + * Declaration value with comments. + */ + value?: { + raw: string + value: string + } + } + + export interface DeclarationProps { + /** Whether the declaration has an `!important` annotation. */ + important?: boolean + /** Name of the declaration. */ + prop: string + /** Information used to generate byte-to-byte equal node string as it was in the origin input. */ + raws?: DeclarationRaws + /** Value of the declaration. */ + value: string + } + + export { Declaration_ as default } +} + +/** + * It represents a class that handles + * [CSS declarations](https://developer.mozilla.org/en-US/docs/Web/CSS/Syntax#css_declarations) + * + * ```js + * Once (root, { Declaration }) { + * const color = new Declaration({ prop: 'color', value: 'black' }) + * root.append(color) + * } + * ``` + * + * ```js + * const root = postcss.parse('a { color: black }') + * const decl = root.first?.first + * + * decl.type //=> 'decl' + * decl.toString() //=> ' color: black' + * ``` + */ +declare class Declaration_ extends Node { + parent: ContainerWithChildren | undefined + raws: Declaration.DeclarationRaws + + type: 'decl' + + /** + * It represents a specificity of the declaration. + * + * If true, the CSS declaration will have an + * [important](https://developer.mozilla.org/en-US/docs/Web/CSS/important) + * specifier. + * + * ```js + * const root = postcss.parse('a { color: black !important; color: red }') + * + * root.first.first.important //=> true + * root.first.last.important //=> undefined + * ``` + */ + get important(): boolean + set important(value: boolean) + + /** + * The property name for a CSS declaration. + * + * ```js + * const root = postcss.parse('a { color: black }') + * const decl = root.first.first + * + * decl.prop //=> 'color' + * ``` + */ + get prop(): string + + set prop(value: string) + + /** + * The property value for a CSS declaration. + * + * Any CSS comments inside the value string will be filtered out. + * CSS comments present in the source value will be available in + * the `raws` property. + * + * Assigning new `value` would ignore the comments in `raws` + * property while compiling node to string. + * + * ```js + * const root = postcss.parse('a { color: black }') + * const decl = root.first.first + * + * decl.value //=> 'black' + * ``` + */ + get value(): string + set value(value: string) + + /** + * It represents a getter that returns `true` if a declaration starts with + * `--` or `$`, which are used to declare variables in CSS and SASS/SCSS. + * + * ```js + * const root = postcss.parse(':root { --one: 1 }') + * const one = root.first.first + * + * one.variable //=> true + * ``` + * + * ```js + * const root = postcss.parse('$one: 1') + * const one = root.first + * + * one.variable //=> true + * ``` + */ + get variable(): boolean + constructor(defaults?: Declaration.DeclarationProps) + + assign(overrides: Declaration.DeclarationProps | object): this + clone(overrides?: Partial): this + cloneAfter(overrides?: Partial): this + cloneBefore(overrides?: Partial): this +} + +declare class Declaration extends Declaration_ {} + +export = Declaration diff --git a/frontend/node_modules/postcss/lib/declaration.js b/frontend/node_modules/postcss/lib/declaration.js new file mode 100644 index 0000000..65a03aa --- /dev/null +++ b/frontend/node_modules/postcss/lib/declaration.js @@ -0,0 +1,24 @@ +'use strict' + +let Node = require('./node') + +class Declaration extends Node { + get variable() { + return this.prop.startsWith('--') || this.prop[0] === '$' + } + + constructor(defaults) { + if ( + defaults && + typeof defaults.value !== 'undefined' && + typeof defaults.value !== 'string' + ) { + defaults = { ...defaults, value: String(defaults.value) } + } + super(defaults) + this.type = 'decl' + } +} + +module.exports = Declaration +Declaration.default = Declaration diff --git a/frontend/node_modules/postcss/lib/document.d.ts b/frontend/node_modules/postcss/lib/document.d.ts new file mode 100644 index 0000000..67194dd --- /dev/null +++ b/frontend/node_modules/postcss/lib/document.d.ts @@ -0,0 +1,68 @@ +import Container, { ContainerProps } from './container.js' +import { ProcessOptions } from './postcss.js' +import Result from './result.js' +import Root from './root.js' + +declare namespace Document { + export interface DocumentProps extends ContainerProps { + nodes?: readonly Root[] + + /** + * Information to generate byte-to-byte equal node string as it was + * in the origin input. + * + * Every parser saves its own properties. + */ + raws?: Record + } + + export { Document_ as default } +} + +/** + * Represents a file and contains all its parsed nodes. + * + * **Experimental:** some aspects of this node could change within minor + * or patch version releases. + * + * ```js + * const document = htmlParser( + * '' + * ) + * document.type //=> 'document' + * document.nodes.length //=> 2 + * ``` + */ +declare class Document_ extends Container { + nodes: Root[] + parent: undefined + type: 'document' + + constructor(defaults?: Document.DocumentProps) + + assign(overrides: Document.DocumentProps | object): this + clone(overrides?: Partial): this + cloneAfter(overrides?: Partial): this + cloneBefore(overrides?: Partial): this + + /** + * Returns a `Result` instance representing the document’s CSS roots. + * + * ```js + * const root1 = postcss.parse(css1, { from: 'a.css' }) + * const root2 = postcss.parse(css2, { from: 'b.css' }) + * const document = postcss.document() + * document.append(root1) + * document.append(root2) + * const result = document.toResult({ to: 'all.css', map: true }) + * ``` + * + * @param opts Options. + * @return Result with current document’s CSS. + */ + toResult(options?: ProcessOptions): Result +} + +declare class Document extends Document_ {} + +export = Document diff --git a/frontend/node_modules/postcss/lib/document.js b/frontend/node_modules/postcss/lib/document.js new file mode 100644 index 0000000..4468991 --- /dev/null +++ b/frontend/node_modules/postcss/lib/document.js @@ -0,0 +1,33 @@ +'use strict' + +let Container = require('./container') + +let LazyResult, Processor + +class Document extends Container { + constructor(defaults) { + // type needs to be passed to super, otherwise child roots won't be normalized correctly + super({ type: 'document', ...defaults }) + + if (!this.nodes) { + this.nodes = [] + } + } + + toResult(opts = {}) { + let lazy = new LazyResult(new Processor(), this, opts) + + return lazy.stringify() + } +} + +Document.registerLazyResult = dependant => { + LazyResult = dependant +} + +Document.registerProcessor = dependant => { + Processor = dependant +} + +module.exports = Document +Document.default = Document diff --git a/frontend/node_modules/postcss/lib/fromJSON.d.ts b/frontend/node_modules/postcss/lib/fromJSON.d.ts new file mode 100644 index 0000000..3a0c5b8 --- /dev/null +++ b/frontend/node_modules/postcss/lib/fromJSON.d.ts @@ -0,0 +1,9 @@ +import { JSONHydrator } from './postcss.js' + +interface FromJSON extends JSONHydrator { + default: FromJSON +} + +declare let fromJSON: FromJSON + +export = fromJSON diff --git a/frontend/node_modules/postcss/lib/fromJSON.js b/frontend/node_modules/postcss/lib/fromJSON.js new file mode 100644 index 0000000..a43686d --- /dev/null +++ b/frontend/node_modules/postcss/lib/fromJSON.js @@ -0,0 +1,68 @@ +'use strict' + +let AtRule = require('./at-rule') +let Comment = require('./comment') +let Declaration = require('./declaration') +let Input = require('./input') +let PreviousMap = require('./previous-map') +let Root = require('./root') +let Rule = require('./rule') + +function fromJSON(json, inputs) { + if (Array.isArray(json)) return json.map(n => fromJSON(n)) + + let { inputs: ownInputs, ...defaults } = json + if (ownInputs) { + inputs = [] + for (let input of ownInputs) { + let inputHydrated = { ...input, __proto__: Input.prototype } + if (inputHydrated.map) { + inputHydrated.map = { + ...inputHydrated.map, + __proto__: PreviousMap.prototype + } + } + inputs.push(inputHydrated) + } + } + // Rehydrate children separately and attach them after construction. + // Passing them through the container constructor would re-run insertion + // spacing normalization and overwrite each child's own `raws.before`. + let nodes + if (defaults.nodes) { + nodes = json.nodes.map(n => fromJSON(n, inputs)) + delete defaults.nodes + } + if (defaults.source) { + let { inputId, ...source } = defaults.source + defaults.source = source + if (inputId != null) { + defaults.source.input = inputs[inputId] + } + } + + let node + if (defaults.type === 'root') { + node = new Root(defaults) + } else if (defaults.type === 'decl') { + node = new Declaration(defaults) + } else if (defaults.type === 'rule') { + node = new Rule(defaults) + } else if (defaults.type === 'comment') { + node = new Comment(defaults) + } else if (defaults.type === 'atrule') { + node = new AtRule(defaults) + } else { + throw new Error('Unknown node type: ' + json.type) + } + + if (nodes) { + node.nodes = nodes + for (let child of nodes) child.parent = node + } + + return node +} + +module.exports = fromJSON +fromJSON.default = fromJSON diff --git a/frontend/node_modules/postcss/lib/input.d.ts b/frontend/node_modules/postcss/lib/input.d.ts new file mode 100644 index 0000000..ca2d26b --- /dev/null +++ b/frontend/node_modules/postcss/lib/input.d.ts @@ -0,0 +1,226 @@ +import { CssSyntaxError, ProcessOptions } from './postcss.js' +import PreviousMap from './previous-map.js' + +declare namespace Input { + export interface FilePosition { + /** + * Column of inclusive start position in source file. + */ + column: number + + /** + * Column of exclusive end position in source file. + */ + endColumn?: number + + /** + * Line of exclusive end position in source file. + */ + endLine?: number + + /** + * Offset of exclusive end position in source file. + */ + endOffset?: number + + /** + * Absolute path to the source file. + */ + file?: string + + /** + * Line of inclusive start position in source file. + */ + line: number + + /** + * Offset of inclusive start position in source file. + */ + offset: number + + /** + * Source code. + */ + source?: string + + /** + * URL for the source file. + */ + url: string + } + + export { Input_ as default } +} + +/** + * Represents the source CSS. + * + * ```js + * const root = postcss.parse(css, { from: file }) + * const input = root.source.input + * ``` + */ +declare class Input_ { + /** + * Input CSS source. + * + * ```js + * const input = postcss.parse('a{}', { from: file }).input + * input.css //=> "a{}" + * ``` + */ + css: string + + /** + * Input source with support for non-CSS documents. + * + * ```js + * const input = postcss.parse('a{}', { from: file, document: '' }).input + * input.document //=> "" + * input.css //=> "a{}" + * ``` + */ + document: string + + /** + * The absolute path to the CSS source file defined + * with the `from` option. + * + * ```js + * const root = postcss.parse(css, { from: 'a.css' }) + * root.source.input.file //=> '/home/ai/a.css' + * ``` + */ + file?: string + + /** + * The flag to indicate whether or not the source code has Unicode BOM. + */ + hasBOM: boolean + + /** + * The unique ID of the CSS source. It will be created if `from` option + * is not provided (because PostCSS does not know the file path). + * + * ```js + * const root = postcss.parse(css) + * root.source.input.file //=> undefined + * root.source.input.id //=> "" + * ``` + */ + id?: string + + /** + * The input source map passed from a compilation step before PostCSS + * (for example, from Sass compiler). + * + * ```js + * root.source.input.map.consumer().sources //=> ['a.sass'] + * ``` + */ + map: PreviousMap + + /** + * The CSS source identifier. Contains `Input#file` if the user + * set the `from` option, or `Input#id` if they did not. + * + * ```js + * const root = postcss.parse(css, { from: 'a.css' }) + * root.source.input.from //=> "/home/ai/a.css" + * + * const root = postcss.parse(css) + * root.source.input.from //=> "" + * ``` + */ + get from(): string + + /** + * @param css Input CSS source. + * @param opts Process options. + */ + constructor(css: string, opts?: ProcessOptions) + + /** + * Returns `CssSyntaxError` with information about the error and its position. + */ + error( + message: string, + start: + | { + column: number + line: number + } + | { + offset: number + }, + end: + | { + column: number + line: number + } + | { + offset: number + }, + opts?: { plugin?: CssSyntaxError['plugin'] } + ): CssSyntaxError + error( + message: string, + line: number, + column: number, + opts?: { plugin?: CssSyntaxError['plugin'] } + ): CssSyntaxError + error( + message: string, + offset: number, + opts?: { plugin?: CssSyntaxError['plugin'] } + ): CssSyntaxError + + /** + * Converts source line and column to offset. + * + * @param line Source line. + * @param column Source column. + * @return Source offset. + */ + fromLineAndColumn(line: number, column: number): number + + /** + * Converts source offset to line and column. + * + * @param offset Source offset. + */ + fromOffset(offset: number): { col: number; line: number } | null + + /** + * Reads the input source map and returns a symbol position + * in the input source (e.g., in a Sass file that was compiled + * to CSS before being passed to PostCSS). Optionally takes an + * end position, exclusive. + * + * ```js + * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 } + * root.source.input.origin(1, 1, 1, 4) + * //=> { file: 'a.css', line: 3, column: 1, endLine: 3, endColumn: 4 } + * ``` + * + * @param line Line for inclusive start position in input CSS. + * @param column Column for inclusive start position in input CSS. + * @param endLine Line for exclusive end position in input CSS. + * @param endColumn Column for exclusive end position in input CSS. + * + * @return Position in input source. + */ + origin( + line: number, + column: number, + endLine?: number, + endColumn?: number + ): false | Input.FilePosition + + /** Converts this to a JSON-friendly object representation. */ + toJSON(): object +} + +declare class Input extends Input_ {} + +export = Input diff --git a/frontend/node_modules/postcss/lib/input.js b/frontend/node_modules/postcss/lib/input.js new file mode 100644 index 0000000..88a9c80 --- /dev/null +++ b/frontend/node_modules/postcss/lib/input.js @@ -0,0 +1,276 @@ +'use strict' + +let { nanoid } = require('nanoid/non-secure') +let { isAbsolute, resolve } = require('path') +let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js') +let { fileURLToPath, pathToFileURL } = require('url') + +let CssSyntaxError = require('./css-syntax-error') +let PreviousMap = require('./previous-map') +let terminalHighlight = require('./terminal-highlight') + +let lineToIndexCache = Symbol('lineToIndexCache') + +let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) +let pathAvailable = Boolean(resolve && isAbsolute) + +function getLineToIndex(input) { + if (input[lineToIndexCache]) return input[lineToIndexCache] + let lines = input.css.split('\n') + let lineToIndex = new Array(lines.length) + let prevIndex = 0 + + for (let i = 0, l = lines.length; i < l; i++) { + lineToIndex[i] = prevIndex + prevIndex += lines[i].length + 1 + } + + input[lineToIndexCache] = lineToIndex + return lineToIndex +} + +class Input { + get from() { + return this.file || this.id + } + + constructor(css, opts = {}) { + if ( + css === null || + typeof css === 'undefined' || + (typeof css === 'object' && !css.toString) + ) { + throw new Error(`PostCSS received ${css} instead of CSS string`) + } + + this.css = css.toString() + + if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') { + this.hasBOM = true + this.css = this.css.slice(1) + } else { + this.hasBOM = false + } + + this.document = this.css + if (opts.document) this.document = opts.document.toString() + + if (opts.from) { + if ( + !pathAvailable || + /^\w+:\/\//.test(opts.from) || + isAbsolute(opts.from) + ) { + this.file = opts.from + } else { + this.file = resolve(opts.from) + } + } + + if (pathAvailable && sourceMapAvailable) { + let map = new PreviousMap(this.css, opts) + if (map.text) { + this.map = map + let file = map.consumer().file + if (!this.file && file) this.file = this.mapResolve(file) + } + } + + if (!this.file) { + this.id = '' + } + if (this.map) this.map.file = this.from + } + + error(message, line, column, opts = {}) { + let endColumn, endLine, endOffset, offset, result + + if (line && typeof line === 'object') { + let start = line + let end = column + if (typeof start.offset === 'number') { + offset = start.offset + let pos = this.fromOffset(offset) + line = pos.line + column = pos.col + } else { + line = start.line + column = start.column + offset = this.fromLineAndColumn(line, column) + } + if (typeof end.offset === 'number') { + endOffset = end.offset + let pos = this.fromOffset(endOffset) + endLine = pos.line + endColumn = pos.col + } else { + endLine = end.line + endColumn = end.column + endOffset = this.fromLineAndColumn(end.line, end.column) + } + } else if (!column) { + offset = line + let pos = this.fromOffset(offset) + line = pos.line + column = pos.col + } else { + offset = this.fromLineAndColumn(line, column) + } + + let origin = this.origin(line, column, endLine, endColumn) + if (origin) { + result = new CssSyntaxError( + message, + origin.endLine === undefined + ? origin.line + : { column: origin.column, line: origin.line }, + origin.endLine === undefined + ? origin.column + : { column: origin.endColumn, line: origin.endLine }, + origin.source, + origin.file, + opts.plugin + ) + } else { + result = new CssSyntaxError( + message, + endLine === undefined ? line : { column, line }, + endLine === undefined ? column : { column: endColumn, line: endLine }, + this.css, + this.file, + opts.plugin + ) + } + + result.input = { + column, + endColumn, + endLine, + endOffset, + line, + offset, + source: this.css + } + if (this.file) { + if (pathToFileURL) { + result.input.url = pathToFileURL(this.file).toString() + } + result.input.file = this.file + } + + return result + } + + fromLineAndColumn(line, column) { + let lineToIndex = getLineToIndex(this) + let index = lineToIndex[line - 1] + return index + column - 1 + } + + fromOffset(offset) { + let lineToIndex = getLineToIndex(this) + let lastLine = lineToIndex[lineToIndex.length - 1] + + let min = 0 + if (offset >= lastLine) { + min = lineToIndex.length - 1 + } else { + let max = lineToIndex.length - 2 + let mid + while (min < max) { + mid = min + ((max - min) >> 1) + if (offset < lineToIndex[mid]) { + max = mid - 1 + } else if (offset >= lineToIndex[mid + 1]) { + min = mid + 1 + } else { + min = mid + break + } + } + } + return { + col: offset - lineToIndex[min] + 1, + line: min + 1 + } + } + + mapResolve(file) { + if (/^\w+:\/\//.test(file)) { + return file + } + return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file) + } + + origin(line, column, endLine, endColumn) { + if (!this.map) return false + let consumer = this.map.consumer() + + let from = consumer.originalPositionFor({ column: column - 1, line }) + if (!from.source) return false + + let to + if (typeof endLine === 'number') { + to = consumer.originalPositionFor({ + column: endColumn - 1, + line: endLine + }) + } + + let fromUrl + + if (isAbsolute(from.source)) { + fromUrl = pathToFileURL(from.source) + } else { + fromUrl = new URL( + from.source, + this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile) + ) + } + + let result = { + column: from.column + 1, + endColumn: to && to.column + 1, + endLine: to && to.line, + line: from.line, + url: fromUrl.toString() + } + + if (fromUrl.protocol === 'file:') { + if (fileURLToPath) { + result.file = fileURLToPath(fromUrl) + } else { + /* c8 ignore next 2 */ + throw new Error(`file: protocol is not available in this PostCSS build`) + } + } + + let source = consumer.sourceContentFor(from.source) + if (source) result.source = source + + return result + } + + toJSON() { + let json = {} + for (let name of ['hasBOM', 'css', 'file', 'id']) { + if (this[name] != null) { + json[name] = this[name] + } + } + if (this.map) { + json.map = { ...this.map } + if (json.map.consumerCache) { + json.map.consumerCache = undefined + } + } + return json + } +} + +module.exports = Input +Input.default = Input + +if (terminalHighlight && terminalHighlight.registerInput) { + terminalHighlight.registerInput(Input) +} diff --git a/frontend/node_modules/postcss/lib/lazy-result.d.ts b/frontend/node_modules/postcss/lib/lazy-result.d.ts new file mode 100644 index 0000000..599a614 --- /dev/null +++ b/frontend/node_modules/postcss/lib/lazy-result.d.ts @@ -0,0 +1,189 @@ +import Document from './document.js' +import { SourceMap } from './postcss.js' +import Processor from './processor.js' +import Result, { Message, ResultOptions } from './result.js' +import Root from './root.js' +import Warning from './warning.js' + +declare namespace LazyResult { + export { LazyResult_ as default } +} + +/** + * A Promise proxy for the result of PostCSS transformations. + * + * A `LazyResult` instance is returned by `Processor#process`. + * + * ```js + * const lazy = postcss([autoprefixer]).process(css) + * ``` + */ +declare class LazyResult_ implements PromiseLike< + Result +> { + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls onRejected for each error thrown in any plugin. + * + * It implements standard Promise API. + * + * ```js + * postcss([autoprefixer]).process(css).then(result => { + * console.log(result.css) + * }).catch(error => { + * console.error(error) + * }) + * ``` + */ + catch: Promise>['catch'] + + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls onFinally on any error or when all plugins will finish work. + * + * It implements standard Promise API. + * + * ```js + * postcss([autoprefixer]).process(css).finally(() => { + * console.log('processing ended') + * }) + * ``` + */ + finally: Promise>['finally'] + + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls `onFulfilled` with a Result instance. If a plugin throws + * an error, the `onRejected` callback will be executed. + * + * It implements standard Promise API. + * + * ```js + * postcss([autoprefixer]).process(css, { from: cssPath }).then(result => { + * console.log(result.css) + * }) + * ``` + */ + then: Promise>['then'] + + /** + * An alias for the `css` property. Use it with syntaxes + * that generate non-CSS output. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get content(): string + + /** + * Processes input CSS through synchronous plugins, converts `Root` + * to a CSS string and returns `Result#css`. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get css(): string + + /** + * Processes input CSS through synchronous plugins + * and returns `Result#map`. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get map(): SourceMap + + /** + * Processes input CSS through synchronous plugins + * and returns `Result#messages`. + * + * This property will only work with synchronous plugins. If the processor + * contains any asynchronous plugins it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get messages(): Message[] + + /** + * Options from the `Processor#process` call. + */ + get opts(): ResultOptions + + /** + * Returns a `Processor` instance, which will be used + * for CSS transformations. + */ + get processor(): Processor + + /** + * Processes input CSS through synchronous plugins + * and returns `Result#root`. + * + * This property will only work with synchronous plugins. If the processor + * contains any asynchronous plugins it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get root(): RootNode + + /** + * Returns the default string description of an object. + * Required to implement the Promise interface. + */ + get [Symbol.toStringTag](): string + + /** + * @param processor Processor used for this transformation. + * @param css CSS to parse and transform. + * @param opts Options from the `Processor#process` or `Root#toResult`. + */ + constructor(processor: Processor, css: string, opts: ResultOptions) + + /** + * Run plugin in async way and return `Result`. + * + * @return Result with output content. + */ + async(): Promise> + + /** + * Run plugin in sync way and return `Result`. + * + * @return Result with output content. + */ + sync(): Result + + /** + * Alias for the `LazyResult#css` property. + * + * ```js + * lazy + '' === lazy.css + * ``` + * + * @return Output CSS. + */ + toString(): string + + /** + * Processes input CSS through synchronous plugins + * and calls `Result#warnings`. + * + * @return Warnings from plugins. + */ + warnings(): Warning[] +} + +declare class LazyResult< + RootNode = Document | Root +> extends LazyResult_ {} + +export = LazyResult diff --git a/frontend/node_modules/postcss/lib/lazy-result.js b/frontend/node_modules/postcss/lib/lazy-result.js new file mode 100644 index 0000000..9026a7c --- /dev/null +++ b/frontend/node_modules/postcss/lib/lazy-result.js @@ -0,0 +1,563 @@ +'use strict' + +let Container = require('./container') +let Document = require('./document') +let MapGenerator = require('./map-generator') +let parse = require('./parse') +let Result = require('./result') +let Root = require('./root') +let stringify = require('./stringify') +let { isClean, my } = require('./symbols') +let warnOnce = require('./warn-once') + +const TYPE_TO_CLASS_NAME = { + atrule: 'AtRule', + comment: 'Comment', + decl: 'Declaration', + document: 'Document', + root: 'Root', + rule: 'Rule' +} + +const PLUGIN_PROPS = { + AtRule: true, + AtRuleExit: true, + Comment: true, + CommentExit: true, + Declaration: true, + DeclarationExit: true, + Document: true, + DocumentExit: true, + Once: true, + OnceExit: true, + postcssPlugin: true, + prepare: true, + Root: true, + RootExit: true, + Rule: true, + RuleExit: true +} + +const NOT_VISITORS = { + Once: true, + postcssPlugin: true, + prepare: true +} + +const CHILDREN = 0 + +function isPromise(obj) { + return typeof obj === 'object' && typeof obj.then === 'function' +} + +function getEvents(node) { + let key = false + let type = TYPE_TO_CLASS_NAME[node.type] + if (node.type === 'decl') { + key = node.prop.toLowerCase() + } else if (node.type === 'atrule') { + key = node.name.toLowerCase() + } + + if (key && node.append) { + return [ + type, + type + '-' + key, + CHILDREN, + type + 'Exit', + type + 'Exit-' + key + ] + } else if (key) { + return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key] + } else if (node.append) { + return [type, CHILDREN, type + 'Exit'] + } else { + return [type, type + 'Exit'] + } +} + +function toStack(node) { + let events + if (node.type === 'document') { + events = ['Document', CHILDREN, 'DocumentExit'] + } else if (node.type === 'root') { + events = ['Root', CHILDREN, 'RootExit'] + } else { + events = getEvents(node) + } + + return { + eventIndex: 0, + events, + iterator: 0, + node, + visitorIndex: 0, + visitors: [] + } +} + +function cleanMarks(node) { + node[isClean] = false + if (node.nodes) node.nodes.forEach(i => cleanMarks(i)) + return node +} + +let postcss = {} + +class LazyResult { + get content() { + return this.stringify().content + } + + get css() { + return this.stringify().css + } + + get map() { + return this.stringify().map + } + + get messages() { + return this.sync().messages + } + + get opts() { + return this.result.opts + } + + get processor() { + return this.result.processor + } + + get root() { + return this.sync().root + } + + get [Symbol.toStringTag]() { + return 'LazyResult' + } + + constructor(processor, css, opts) { + this.stringified = false + this.processed = false + + let root + if ( + typeof css === 'object' && + css !== null && + (css.type === 'root' || css.type === 'document') + ) { + root = cleanMarks(css) + } else if (css instanceof LazyResult || css instanceof Result) { + root = cleanMarks(css.root) + if (css.map) { + if (typeof opts.map === 'undefined') opts.map = {} + if (!opts.map.inline) opts.map.inline = false + opts.map.prev = css.map + } + } else { + let parser = parse + if (opts.syntax) parser = opts.syntax.parse + if (opts.parser) parser = opts.parser + if (parser.parse) parser = parser.parse + + try { + root = parser(css, opts) + } catch (error) { + this.processed = true + this.error = error + } + + if (root && !root[my]) { + /* c8 ignore next 2 */ + Container.rebuild(root) + } + } + + this.result = new Result(processor, root, opts) + this.helpers = { ...postcss, postcss, result: this.result } + this.plugins = this.processor.plugins.map(plugin => { + if (typeof plugin === 'object' && plugin.prepare) { + return { ...plugin, ...plugin.prepare(this.result) } + } else { + return plugin + } + }) + } + + async() { + if (this.error) return Promise.reject(this.error) + if (this.processed) return Promise.resolve(this.result) + if (!this.processing) { + this.processing = this.runAsync() + } + return this.processing + } + + catch(onRejected) { + return this.async().catch(onRejected) + } + + finally(onFinally) { + return this.async().then(onFinally, onFinally) + } + + getAsyncError() { + throw new Error('Use process(css).then(cb) to work with async plugins') + } + + handleError(error, node) { + let plugin = this.result.lastPlugin + try { + if (node) node.addToError(error) + this.error = error + if (error.name === 'CssSyntaxError' && !error.plugin) { + error.plugin = plugin.postcssPlugin + error.setMessage() + } else if (plugin.postcssVersion) { + if (process.env.NODE_ENV !== 'production') { + let pluginName = plugin.postcssPlugin + let pluginVer = plugin.postcssVersion + let runtimeVer = this.result.processor.version + let a = pluginVer.split('.') + let b = runtimeVer.split('.') + + if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) { + // eslint-disable-next-line no-console + console.error( + 'Unknown error from PostCSS plugin. Your current PostCSS ' + + 'version is ' + + runtimeVer + + ', but ' + + pluginName + + ' uses ' + + pluginVer + + '. Perhaps this is the source of the error below.' + ) + } + } + } + } catch (err) { + /* c8 ignore next 3 */ + // eslint-disable-next-line no-console + if (console && console.error) console.error(err) + } + return error + } + + prepareVisitors() { + this.listeners = {} + let add = (plugin, type, cb) => { + if (!this.listeners[type]) this.listeners[type] = [] + this.listeners[type].push([plugin, cb]) + } + for (let plugin of this.plugins) { + if (typeof plugin === 'object') { + for (let event in plugin) { + if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) { + throw new Error( + `Unknown event ${event} in ${plugin.postcssPlugin}. ` + + `Try to update PostCSS (${this.processor.version} now).` + ) + } + if (!NOT_VISITORS[event]) { + if (typeof plugin[event] === 'object') { + for (let filter in plugin[event]) { + if (filter === '*') { + add(plugin, event, plugin[event][filter]) + } else { + add( + plugin, + event + '-' + filter.toLowerCase(), + plugin[event][filter] + ) + } + } + } else if (typeof plugin[event] === 'function') { + add(plugin, event, plugin[event]) + } + } + } + } + } + this.hasListener = Object.keys(this.listeners).length > 0 + } + + async runAsync() { + this.plugin = 0 + for (let i = 0; i < this.plugins.length; i++) { + let plugin = this.plugins[i] + let promise = this.runOnRoot(plugin) + if (isPromise(promise)) { + try { + await promise + } catch (error) { + throw this.handleError(error) + } + } + } + + this.prepareVisitors() + if (this.hasListener) { + let root = this.result.root + while (!root[isClean]) { + root[isClean] = true + let stack = [toStack(root)] + while (stack.length > 0) { + let promise = this.visitTick(stack) + if (isPromise(promise)) { + try { + await promise + } catch (e) { + let node = stack[stack.length - 1].node + throw this.handleError(e, node) + } + } + } + } + + if (this.listeners.OnceExit) { + for (let [plugin, visitor] of this.listeners.OnceExit) { + this.result.lastPlugin = plugin + try { + if (root.type === 'document') { + let roots = root.nodes.map(subRoot => + visitor(subRoot, this.helpers) + ) + + await Promise.all(roots) + } else { + await visitor(root, this.helpers) + } + } catch (e) { + throw this.handleError(e) + } + } + } + } + + this.processed = true + return this.stringify() + } + + runOnRoot(plugin) { + this.result.lastPlugin = plugin + try { + if (typeof plugin === 'object' && plugin.Once) { + if (this.result.root.type === 'document') { + let roots = this.result.root.nodes.map(root => + plugin.Once(root, this.helpers) + ) + + if (isPromise(roots[0])) { + return Promise.all(roots) + } + + return roots + } + + return plugin.Once(this.result.root, this.helpers) + } else if (typeof plugin === 'function') { + return plugin(this.result.root, this.result) + } + } catch (error) { + throw this.handleError(error) + } + } + + stringify() { + if (this.error) throw this.error + if (this.stringified) return this.result + this.stringified = true + + this.sync() + + let opts = this.result.opts + let str = stringify + if (opts.syntax) str = opts.syntax.stringify + if (opts.stringifier) str = opts.stringifier + if (str.stringify) str = str.stringify + + let rootSource = this.result.root.source + if ( + opts.map === undefined && + !(rootSource && rootSource.input && rootSource.input.map) + ) { + let result = '' + str(this.result.root, i => { + result += i + }) + this.result.css = result + return this.result + } + + let map = new MapGenerator(str, this.result.root, this.result.opts) + let data = map.generate() + this.result.css = data[0] + this.result.map = data[1] + + return this.result + } + + sync() { + if (this.error) throw this.error + if (this.processed) return this.result + this.processed = true + + if (this.processing) { + throw this.getAsyncError() + } + + for (let plugin of this.plugins) { + let promise = this.runOnRoot(plugin) + if (isPromise(promise)) { + throw this.getAsyncError() + } + } + + this.prepareVisitors() + if (this.hasListener) { + let root = this.result.root + while (!root[isClean]) { + root[isClean] = true + this.walkSync(root) + } + if (this.listeners.OnceExit) { + if (root.type === 'document') { + for (let subRoot of root.nodes) { + this.visitSync(this.listeners.OnceExit, subRoot) + } + } else { + this.visitSync(this.listeners.OnceExit, root) + } + } + } + + return this.result + } + + then(onFulfilled, onRejected) { + if (process.env.NODE_ENV !== 'production') { + if (!('from' in this.opts)) { + warnOnce( + 'Without `from` option PostCSS could generate wrong source map ' + + 'and will not find Browserslist config. Set it to CSS file path ' + + 'or to `undefined` to prevent this warning.' + ) + } + } + return this.async().then(onFulfilled, onRejected) + } + + toString() { + return this.css + } + + visitSync(visitors, node) { + for (let [plugin, visitor] of visitors) { + this.result.lastPlugin = plugin + let promise + try { + promise = visitor(node, this.helpers) + } catch (e) { + throw this.handleError(e, node.proxyOf) + } + if (node.type !== 'root' && node.type !== 'document' && !node.parent) { + return true + } + if (isPromise(promise)) { + throw this.getAsyncError() + } + } + } + + visitTick(stack) { + let visit = stack[stack.length - 1] + let { node, visitors } = visit + + if (node.type !== 'root' && node.type !== 'document' && !node.parent) { + stack.pop() + return + } + + if (visitors.length > 0 && visit.visitorIndex < visitors.length) { + let [plugin, visitor] = visitors[visit.visitorIndex] + visit.visitorIndex += 1 + if (visit.visitorIndex === visitors.length) { + visit.visitors = [] + visit.visitorIndex = 0 + } + this.result.lastPlugin = plugin + try { + return visitor(node.toProxy(), this.helpers) + } catch (e) { + throw this.handleError(e, node) + } + } + + if (visit.iterator !== 0) { + let iterator = visit.iterator + let child + while ((child = node.nodes[node.indexes[iterator]])) { + node.indexes[iterator] += 1 + if (!child[isClean]) { + child[isClean] = true + stack.push(toStack(child)) + return + } + } + visit.iterator = 0 + delete node.indexes[iterator] + } + + let events = visit.events + while (visit.eventIndex < events.length) { + let event = events[visit.eventIndex] + visit.eventIndex += 1 + if (event === CHILDREN) { + if (node.nodes && node.nodes.length) { + node[isClean] = true + visit.iterator = node.getIterator() + } + return + } else if (this.listeners[event]) { + visit.visitors = this.listeners[event] + return + } + } + stack.pop() + } + + walkSync(node) { + node[isClean] = true + let events = getEvents(node) + for (let event of events) { + if (event === CHILDREN) { + if (node.nodes) { + node.each(child => { + if (!child[isClean]) this.walkSync(child) + }) + } + } else { + let visitors = this.listeners[event] + if (visitors) { + if (this.visitSync(visitors, node.toProxy())) return + } + } + } + } + + warnings() { + return this.sync().warnings() + } +} + +LazyResult.registerPostcss = dependant => { + postcss = dependant +} + +module.exports = LazyResult +LazyResult.default = LazyResult + +Root.registerLazyResult(LazyResult) +Document.registerLazyResult(LazyResult) diff --git a/frontend/node_modules/postcss/lib/list.d.ts b/frontend/node_modules/postcss/lib/list.d.ts new file mode 100644 index 0000000..119624e --- /dev/null +++ b/frontend/node_modules/postcss/lib/list.d.ts @@ -0,0 +1,60 @@ +declare namespace list { + type List = { + /** + * Safely splits comma-separated values (such as those for `transition-*` + * and `background` properties). + * + * ```js + * Once (root, { list }) { + * list.comma('black, linear-gradient(white, black)') + * //=> ['black', 'linear-gradient(white, black)'] + * } + * ``` + * + * @param str Comma-separated values. + * @return Split values. + */ + comma(str: string): string[] + + default: List + + /** + * Safely splits space-separated values (such as those for `background`, + * `border-radius`, and other shorthand properties). + * + * ```js + * Once (root, { list }) { + * list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)'] + * } + * ``` + * + * @param str Space-separated values. + * @return Split values. + */ + space(str: string): string[] + + /** + * Safely splits values. + * + * ```js + * Once (root, { list }) { + * list.split('1px calc(10% + 1px)', [' ', '\n', '\t']) //=> ['1px', 'calc(10% + 1px)'] + * } + * ``` + * + * @param string separated values. + * @param separators array of separators. + * @param last boolean indicator. + * @return Split values. + */ + split( + string: string, + separators: readonly string[], + last: boolean + ): string[] + } +} + +declare let list: list.List + +export = list diff --git a/frontend/node_modules/postcss/lib/list.js b/frontend/node_modules/postcss/lib/list.js new file mode 100644 index 0000000..1b31f98 --- /dev/null +++ b/frontend/node_modules/postcss/lib/list.js @@ -0,0 +1,58 @@ +'use strict' + +let list = { + comma(string) { + return list.split(string, [','], true) + }, + + space(string) { + let spaces = [' ', '\n', '\t'] + return list.split(string, spaces) + }, + + split(string, separators, last) { + let array = [] + let current = '' + let split = false + + let func = 0 + let inQuote = false + let prevQuote = '' + let escape = false + + for (let letter of string) { + if (escape) { + escape = false + } else if (letter === '\\') { + escape = true + } else if (inQuote) { + if (letter === prevQuote) { + inQuote = false + } + } else if (letter === '"' || letter === "'") { + inQuote = true + prevQuote = letter + } else if (letter === '(') { + func += 1 + } else if (letter === ')') { + if (func > 0) func -= 1 + } else if (func === 0) { + if (separators.includes(letter)) split = true + } + + if (split) { + if (current !== '') array.push(current.trim()) + current = '' + split = false + } else { + current += letter + } + } + + if (last || current !== '') array.push(current.trim()) + return array + } +} + +module.exports = list +list.default = list diff --git a/frontend/node_modules/postcss/lib/map-generator.js b/frontend/node_modules/postcss/lib/map-generator.js new file mode 100644 index 0000000..df880ac --- /dev/null +++ b/frontend/node_modules/postcss/lib/map-generator.js @@ -0,0 +1,376 @@ +'use strict' + +let { dirname, relative, resolve, sep } = require('path') +let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js') +let { pathToFileURL } = require('url') + +let Input = require('./input') + +let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) +let pathAvailable = Boolean(dirname && resolve && relative && sep) + +class MapGenerator { + constructor(stringify, root, opts, cssString) { + this.stringify = stringify + this.mapOpts = opts.map || {} + this.root = root + this.opts = opts + this.css = cssString + this.originalCSS = cssString + this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute + + this.memoizedFileURLs = new Map() + this.memoizedPaths = new Map() + this.memoizedURLs = new Map() + } + + addAnnotation() { + let content + + if (this.isInline()) { + content = + 'data:application/json;base64,' + this.toBase64(this.map.toString()) + } else if (typeof this.mapOpts.annotation === 'string') { + content = this.mapOpts.annotation + } else if (typeof this.mapOpts.annotation === 'function') { + content = this.mapOpts.annotation(this.opts.to, this.root) + } else { + content = this.outputFile() + '.map' + } + let eol = '\n' + if (this.css.includes('\r\n')) eol = '\r\n' + + this.css += eol + '/*# sourceMappingURL=' + content + ' */' + } + + applyPrevMaps() { + for (let prev of this.previous()) { + let from = this.toUrl(this.path(prev.file)) + let root = prev.root || dirname(prev.file) + let map + + if (this.mapOpts.sourcesContent === false) { + map = new SourceMapConsumer(prev.text) + if (map.sourcesContent) { + map.sourcesContent = null + } + } else { + map = prev.consumer() + } + + this.map.applySourceMap(map, from, this.toUrl(this.path(root))) + } + } + + clearAnnotation() { + if (this.mapOpts.annotation === false) return + + if (this.root) { + let node + for (let i = this.root.nodes.length - 1; i >= 0; i--) { + node = this.root.nodes[i] + if (node.type !== 'comment') continue + if (node.text.startsWith('# sourceMappingURL=')) { + this.root.removeChild(i) + } + } + } else if (this.css) { + let startIndex + while ((startIndex = this.css.lastIndexOf('/*#')) !== -1) { + let endIndex = this.css.indexOf('*/', startIndex + 3) + if (endIndex === -1) break + while (startIndex > 0 && this.css[startIndex - 1] === '\n') { + startIndex-- + } + this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2) + } + } + } + + generate() { + this.clearAnnotation() + if (pathAvailable && sourceMapAvailable && this.isMap()) { + return this.generateMap() + } else { + let result = '' + this.stringify(this.root, i => { + result += i + }) + return [result] + } + } + + generateMap() { + if (this.root) { + this.generateString() + } else if (this.previous().length === 1) { + let prev = this.previous()[0].consumer() + prev.file = this.outputFile() + this.map = SourceMapGenerator.fromSourceMap(prev, { + ignoreInvalidMapping: true + }) + } else { + this.map = new SourceMapGenerator({ + file: this.outputFile(), + ignoreInvalidMapping: true + }) + this.map.addMapping({ + generated: { column: 0, line: 1 }, + original: { column: 0, line: 1 }, + source: this.opts.from + ? this.toUrl(this.path(this.opts.from)) + : '' + }) + } + + if (this.isSourcesContent()) this.setSourcesContent() + if (this.root && this.previous().length > 0) this.applyPrevMaps() + if (this.isAnnotation()) this.addAnnotation() + + if (this.isInline()) { + return [this.css] + } else { + return [this.css, this.map] + } + } + + generateString() { + this.css = '' + this.map = new SourceMapGenerator({ + file: this.outputFile(), + ignoreInvalidMapping: true + }) + + let line = 1 + let column = 1 + + let noSource = '' + let mapping = { + generated: { column: 0, line: 0 }, + original: { column: 0, line: 0 }, + source: '' + } + + let last, lines + this.stringify(this.root, (str, node, type) => { + this.css += str + + if (node && type !== 'end') { + mapping.generated.line = line + mapping.generated.column = column - 1 + if (node.source && node.source.start) { + mapping.source = this.sourcePath(node) + mapping.original.line = node.source.start.line + mapping.original.column = node.source.start.column - 1 + this.map.addMapping(mapping) + } else { + mapping.source = noSource + mapping.original.line = 1 + mapping.original.column = 0 + this.map.addMapping(mapping) + } + } + + lines = str.match(/\n/g) + if (lines) { + line += lines.length + last = str.lastIndexOf('\n') + column = str.length - last + } else { + column += str.length + } + + if (node && type !== 'start') { + let p = node.parent || { raws: {} } + let childless = + node.type === 'decl' || (node.type === 'atrule' && !node.nodes) + if (!childless || node !== p.last || p.raws.semicolon) { + if (node.source && node.source.end) { + mapping.source = this.sourcePath(node) + mapping.original.line = node.source.end.line + mapping.original.column = node.source.end.column - 1 + mapping.generated.line = line + mapping.generated.column = column - 2 + this.map.addMapping(mapping) + } else { + mapping.source = noSource + mapping.original.line = 1 + mapping.original.column = 0 + mapping.generated.line = line + mapping.generated.column = column - 1 + this.map.addMapping(mapping) + } + } + } + }) + } + + isAnnotation() { + if (this.isInline()) { + return true + } + if (typeof this.mapOpts.annotation !== 'undefined') { + return this.mapOpts.annotation + } + if (this.previous().length) { + return this.previous().some(i => i.annotation) + } + return true + } + + isInline() { + if (typeof this.mapOpts.inline !== 'undefined') { + return this.mapOpts.inline + } + + let annotation = this.mapOpts.annotation + if (typeof annotation !== 'undefined' && annotation !== true) { + return false + } + + if (this.previous().length) { + return this.previous().some(i => i.inline) + } + return true + } + + isMap() { + if (typeof this.opts.map !== 'undefined') { + return !!this.opts.map + } + return this.previous().length > 0 + } + + isSourcesContent() { + if (typeof this.mapOpts.sourcesContent !== 'undefined') { + return this.mapOpts.sourcesContent + } + if (this.previous().length) { + return this.previous().some(i => i.withContent()) + } + return true + } + + outputFile() { + if (this.opts.to) { + return this.path(this.opts.to) + } else if (this.opts.from) { + return this.path(this.opts.from) + } else { + return 'to.css' + } + } + + path(file) { + if (this.mapOpts.absolute) return file + if (file.charCodeAt(0) === 60 /* `<` */) return file + if (/^\w+:\/\//.test(file)) return file + let cached = this.memoizedPaths.get(file) + if (cached) return cached + + let from = this.opts.to ? dirname(this.opts.to) : '.' + + if (typeof this.mapOpts.annotation === 'string') { + from = dirname(resolve(from, this.mapOpts.annotation)) + } + + let path = relative(from, file) + this.memoizedPaths.set(file, path) + + return path + } + + previous() { + if (!this.previousMaps) { + this.previousMaps = [] + if (this.root) { + this.root.walk(node => { + if (node.source && node.source.input.map) { + let map = node.source.input.map + if (!this.previousMaps.includes(map)) { + this.previousMaps.push(map) + } + } + }) + } else { + let input = new Input(this.originalCSS, this.opts) + if (input.map) this.previousMaps.push(input.map) + } + } + + return this.previousMaps + } + + setSourcesContent() { + let already = {} + if (this.root) { + this.root.walk(node => { + if (node.source) { + let from = node.source.input.from + if (from && !already[from]) { + already[from] = true + let fromUrl = this.usesFileUrls + ? this.toFileUrl(from) + : this.toUrl(this.path(from)) + this.map.setSourceContent(fromUrl, node.source.input.css) + } + } + }) + } else if (this.css) { + let from = this.opts.from + ? this.toUrl(this.path(this.opts.from)) + : '' + this.map.setSourceContent(from, this.css) + } + } + + sourcePath(node) { + if (this.mapOpts.from) { + return this.toUrl(this.mapOpts.from) + } else if (this.usesFileUrls) { + return this.toFileUrl(node.source.input.from) + } else { + return this.toUrl(this.path(node.source.input.from)) + } + } + + toBase64(str) { + if (Buffer) { + return Buffer.from(str).toString('base64') + } else { + return window.btoa(unescape(encodeURIComponent(str))) + } + } + + toFileUrl(path) { + let cached = this.memoizedFileURLs.get(path) + if (cached) return cached + + if (pathToFileURL) { + let fileURL = pathToFileURL(path).toString() + this.memoizedFileURLs.set(path, fileURL) + + return fileURL + } else { + throw new Error( + '`map.absolute` option is not available in this PostCSS build' + ) + } + } + + toUrl(path) { + let cached = this.memoizedURLs.get(path) + if (cached) return cached + + if (sep === '\\') { + path = path.replace(/\\/g, '/') + } + + let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent) + this.memoizedURLs.set(path, url) + + return url + } +} + +module.exports = MapGenerator diff --git a/frontend/node_modules/postcss/lib/no-work-result.d.ts b/frontend/node_modules/postcss/lib/no-work-result.d.ts new file mode 100644 index 0000000..fa9d284 --- /dev/null +++ b/frontend/node_modules/postcss/lib/no-work-result.d.ts @@ -0,0 +1,45 @@ +import LazyResult from './lazy-result.js' +import { SourceMap } from './postcss.js' +import Processor from './processor.js' +import Result, { Message, ResultOptions } from './result.js' +import Root from './root.js' +import Warning from './warning.js' + +declare namespace NoWorkResult { + export { NoWorkResult_ as default } +} + +/** + * A Promise proxy for the result of PostCSS transformations. + * This lazy result instance doesn't parse css unless `NoWorkResult#root` or `Result#root` + * are accessed. See the example below for details. + * A `NoWork` instance is returned by `Processor#process` ONLY when no plugins defined. + * + * ```js + * const noWorkResult = postcss().process(css) // No plugins are defined. + * // CSS is not parsed + * let root = noWorkResult.root // now css is parsed because we accessed the root + * ``` + */ +declare class NoWorkResult_ implements LazyResult { + catch: Promise>['catch'] + finally: Promise>['finally'] + then: Promise>['then'] + get content(): string + get css(): string + get map(): SourceMap + get messages(): Message[] + get opts(): ResultOptions + get processor(): Processor + get root(): Root + get [Symbol.toStringTag](): string + constructor(processor: Processor, css: string, opts: ResultOptions) + async(): Promise> + sync(): Result + toString(): string + warnings(): Warning[] +} + +declare class NoWorkResult extends NoWorkResult_ {} + +export = NoWorkResult diff --git a/frontend/node_modules/postcss/lib/no-work-result.js b/frontend/node_modules/postcss/lib/no-work-result.js new file mode 100644 index 0000000..7ec1a74 --- /dev/null +++ b/frontend/node_modules/postcss/lib/no-work-result.js @@ -0,0 +1,137 @@ +'use strict' + +let MapGenerator = require('./map-generator') +let parse = require('./parse') +let Result = require('./result') +let stringify = require('./stringify') +let warnOnce = require('./warn-once') + +class NoWorkResult { + get content() { + return this.result.css + } + + get css() { + return this.result.css + } + + get map() { + return this.result.map + } + + get messages() { + return [] + } + + get opts() { + return this.result.opts + } + + get processor() { + return this.result.processor + } + + get root() { + if (this._root) { + return this._root + } + + let root + let parser = parse + + try { + root = parser(this._css, this._opts) + } catch (error) { + this.error = error + } + + if (this.error) { + throw this.error + } else { + this._root = root + return root + } + } + + get [Symbol.toStringTag]() { + return 'NoWorkResult' + } + + constructor(processor, css, opts) { + css = css.toString() + this.stringified = false + + this._processor = processor + this._css = css + this._opts = opts + this._map = undefined + + let str = stringify + this.result = new Result(this._processor, undefined, this._opts) + this.result.css = css + + let self = this + Object.defineProperty(this.result, 'root', { + get() { + return self.root + } + }) + + let map = new MapGenerator(str, undefined, this._opts, css) + if (map.isMap()) { + let [generatedCSS, generatedMap] = map.generate() + if (generatedCSS) { + this.result.css = generatedCSS + } + if (generatedMap) { + this.result.map = generatedMap + } + } else { + map.clearAnnotation() + this.result.css = map.css + } + } + + async() { + if (this.error) return Promise.reject(this.error) + return Promise.resolve(this.result) + } + + catch(onRejected) { + return this.async().catch(onRejected) + } + + finally(onFinally) { + return this.async().then(onFinally, onFinally) + } + + sync() { + if (this.error) throw this.error + return this.result + } + + then(onFulfilled, onRejected) { + if (process.env.NODE_ENV !== 'production') { + if (!('from' in this._opts)) { + warnOnce( + 'Without `from` option PostCSS could generate wrong source map ' + + 'and will not find Browserslist config. Set it to CSS file path ' + + 'or to `undefined` to prevent this warning.' + ) + } + } + + return this.async().then(onFulfilled, onRejected) + } + + toString() { + return this._css + } + + warnings() { + return [] + } +} + +module.exports = NoWorkResult +NoWorkResult.default = NoWorkResult diff --git a/frontend/node_modules/postcss/lib/node.d.ts b/frontend/node_modules/postcss/lib/node.d.ts new file mode 100644 index 0000000..ecd86e2 --- /dev/null +++ b/frontend/node_modules/postcss/lib/node.d.ts @@ -0,0 +1,555 @@ +import AtRule = require('./at-rule.js') +import { AtRuleProps } from './at-rule.js' +import Comment, { CommentProps } from './comment.js' +import Container, { NewChild } from './container.js' +import CssSyntaxError from './css-syntax-error.js' +import Declaration, { DeclarationProps } from './declaration.js' +import Document from './document.js' +import Input from './input.js' +import { Stringifier, Syntax } from './postcss.js' +import Result from './result.js' +import Root from './root.js' +import Rule, { RuleProps } from './rule.js' +import Warning, { WarningOptions } from './warning.js' + +declare namespace Node { + export type ChildNode = AtRule.default | Comment | Declaration | Rule + + export type AnyNode = + | AtRule.default + | Comment + | Declaration + | Document + | Root + | Rule + + export type ChildProps = + | AtRuleProps + | CommentProps + | DeclarationProps + | RuleProps + + export interface Position { + /** + * Source line in file. In contrast to `offset` it starts from 1. + */ + column: number + + /** + * Source column in file. + */ + line: number + + /** + * Source offset in file. It starts from 0. + */ + offset: number + } + + export interface Range { + /** + * End position, exclusive. + */ + end: Position + + /** + * Start position, inclusive. + */ + start: Position + } + + /** + * Source represents an interface for the {@link Node.source} property. + */ + export interface Source { + /** + * The inclusive ending position for the source + * code of a node. + * + * However, `end.offset` of a non `Root` node is the exclusive position. + * See https://github.com/postcss/postcss/pull/1879 for details. + * + * ```js + * const root = postcss.parse('a { color: black }') + * const a = root.first + * const color = a.first + * + * // The offset of `Root` node is the inclusive position + * css.source.end // { line: 1, column: 19, offset: 18 } + * + * // The offset of non `Root` node is the exclusive position + * a.source.end // { line: 1, column: 18, offset: 18 } + * color.source.end // { line: 1, column: 16, offset: 16 } + * ``` + */ + end?: Position + + /** + * The source file from where a node has originated. + */ + input: Input + + /** + * The inclusive starting position for the source + * code of a node. + */ + start?: Position + } + + /** + * Interface represents an interface for an object received + * as parameter by Node class constructor. + */ + export interface NodeProps { + source?: Source + } + + export interface NodeErrorOptions { + /** + * An ending index inside a node's string that should be highlighted as + * source of error. + */ + endIndex?: number + /** + * An index inside a node's string that should be highlighted as source + * of error. + */ + index?: number + /** + * Plugin name that created this error. PostCSS will set it automatically. + */ + plugin?: string + /** + * A word inside a node's string, that should be highlighted as source + * of error. + */ + word?: string + } + + class Node extends Node_ {} + export { Node as default } +} + +/** + * It represents an abstract class that handles common + * methods for other CSS abstract syntax tree nodes. + * + * Any node that represents CSS selector or value should + * not extend the `Node` class. + */ +declare abstract class Node_ { + /** + * It represents parent of the current node. + * + * ```js + * root.nodes[0].parent === root //=> true + * ``` + */ + parent: Container | Document | undefined + + /** + * It represents unnecessary whitespace and characters present + * in the css source code. + * + * Information to generate byte-to-byte equal node string as it was + * in the origin input. + * + * The properties of the raws object are decided by parser, + * the default parser uses the following properties: + * + * * `before`: the space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + * * `after`: the space symbols after the last child of the node + * to the end of the node. + * * `between`: the symbols between the property and value + * for declarations, selector and `{` for rules, or last parameter + * and `{` for at-rules. + * * `semicolon`: contains true if the last child has + * an (optional) semicolon. + * * `afterName`: the space between the at-rule name and its parameters. + * * `left`: the space symbols between `/*` and the comment’s text. + * * `right`: the space symbols between the comment’s text + * and */. + * - `important`: the content of the important statement, + * if it is not just `!important`. + * + * PostCSS filters out the comments inside selectors, declaration values + * and at-rule parameters but it stores the origin content in raws. + * + * ```js + * const root = postcss.parse('a {\n color:black\n}') + * root.first.first.raws //=> { before: '\n ', between: ':' } + * ``` + */ + raws: any + + /** + * It represents information related to origin of a node and is required + * for generating source maps. + * + * The nodes that are created manually using the public APIs + * provided by PostCSS will have `source` undefined and + * will be absent in the source map. + * + * For this reason, the plugin developer should consider + * duplicating nodes as the duplicate node will have the + * same source as the original node by default or assign + * source to a node created manually. + * + * ```js + * decl.source.input.from //=> '/home/ai/source.css' + * decl.source.start //=> { line: 10, column: 2 } + * decl.source.end //=> { line: 10, column: 12 } + * ``` + * + * ```js + * // Incorrect method, source not specified! + * const prefixed = postcss.decl({ + * prop: '-moz-' + decl.prop, + * value: decl.value + * }) + * + * // Correct method, source is inherited when duplicating. + * const prefixed = decl.clone({ + * prop: '-moz-' + decl.prop + * }) + * ``` + * + * ```js + * if (atrule.name === 'add-link') { + * const rule = postcss.rule({ + * selector: 'a', + * source: atrule.source + * }) + * + * atrule.parent.insertBefore(atrule, rule) + * } + * ``` + */ + source?: Node.Source + + /** + * It represents type of a node in + * an abstract syntax tree. + * + * A type of node helps in identification of a node + * and perform operation based on it's type. + * + * ```js + * const declaration = new Declaration({ + * prop: 'color', + * value: 'black' + * }) + * + * declaration.type //=> 'decl' + * ``` + */ + type: string + + constructor(defaults?: object) + + /** + * Insert new node after current node to current node’s parent. + * + * Just alias for `node.parent.insertAfter(node, add)`. + * + * ```js + * decl.after('color: black') + * ``` + * + * @param newNode New node. + * @return This node for methods chain. + */ + after( + newNode: Node | Node.ChildProps | readonly Node[] | string | undefined + ): this + + /** + * It assigns properties to an existing node instance. + * + * ```js + * decl.assign({ prop: 'word-wrap', value: 'break-word' }) + * ``` + * + * @param overrides New properties to override the node. + * + * @return `this` for method chaining. + */ + assign(overrides: object): this + + /** + * Insert new node before current node to current node’s parent. + * + * Just alias for `node.parent.insertBefore(node, add)`. + * + * ```js + * decl.before('content: ""') + * ``` + * + * @param newNode New node. + * @return This node for methods chain. + */ + before( + newNode: Node | Node.ChildProps | readonly Node[] | string | undefined + ): this + + /** + * Clear the code style properties for the node and its children. + * + * ```js + * node.raws.before //=> ' ' + * node.cleanRaws() + * node.raws.before //=> undefined + * ``` + * + * @param keepBetween Keep the `raws.between` symbols. + */ + cleanRaws(keepBetween?: boolean): void + + /** + * It creates clone of an existing node, which includes all the properties + * and their values, that includes `raws` but not `type`. + * + * ```js + * decl.raws.before //=> "\n " + * const cloned = decl.clone({ prop: '-moz-' + decl.prop }) + * cloned.raws.before //=> "\n " + * cloned.toString() //=> -moz-transform: scale(0) + * ``` + * + * @param overrides New properties to override in the clone. + * + * @return Duplicate of the node instance. + */ + clone(overrides?: object): this + + /** + * Shortcut to clone the node and insert the resulting cloned node + * after the current node. + * + * @param overrides New properties to override in the clone. + * @return New node. + */ + cloneAfter(overrides?: object): this + + /** + * Shortcut to clone the node and insert the resulting cloned node + * before the current node. + * + * ```js + * decl.cloneBefore({ prop: '-moz-' + decl.prop }) + * ``` + * + * @param overrides Mew properties to override in the clone. + * + * @return New node + */ + cloneBefore(overrides?: object): this + + /** + * It creates an instance of the class `CssSyntaxError` and parameters passed + * to this method are assigned to the error instance. + * + * The error instance will have description for the + * error, original position of the node in the + * source, showing line and column number. + * + * If any previous map is present, it would be used + * to get original position of the source. + * + * The Previous Map here is referred to the source map + * generated by previous compilation, example: Less, + * Stylus and Sass. + * + * This method returns the error instance instead of + * throwing it. + * + * ```js + * if (!variables[name]) { + * throw decl.error(`Unknown variable ${name}`, { word: name }) + * // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black + * // color: $black + * // a + * // ^ + * // background: white + * } + * ``` + * + * @param message Description for the error instance. + * @param options Options for the error instance. + * + * @return Error instance is returned. + */ + error(message: string, options?: Node.NodeErrorOptions): CssSyntaxError + + /** + * Returns the next child of the node’s parent. + * Returns `undefined` if the current node is the last child. + * + * ```js + * if (comment.text === 'delete next') { + * const next = comment.next() + * if (next) { + * next.remove() + * } + * } + * ``` + * + * @return Next node. + */ + next(): Node.ChildNode | undefined + + /** + * Get the position for a word or an index inside the node. + * + * @param opts Options. + * @return Position. + */ + positionBy(opts?: Pick): Node.Position + + /** + * Convert string index to line/column. + * + * @param index The symbol number in the node’s string. + * @return Symbol position in file. + */ + positionInside(index: number): Node.Position + + /** + * Returns the previous child of the node’s parent. + * Returns `undefined` if the current node is the first child. + * + * ```js + * const annotation = decl.prev() + * if (annotation.type === 'comment') { + * readAnnotation(annotation.text) + * } + * ``` + * + * @return Previous node. + */ + prev(): Node.ChildNode | undefined + + /** + * Get the range for a word or start and end index inside the node. + * The start index is inclusive; the end index is exclusive. + * + * @param opts Options. + * @return Range. + */ + rangeBy( + opts?: Pick + ): Node.Range + + /** + * Returns a `raws` value. If the node is missing + * the code style property (because the node was manually built or cloned), + * PostCSS will try to autodetect the code style property by looking + * at other nodes in the tree. + * + * ```js + * const root = postcss.parse('a { background: white }') + * root.nodes[0].append({ prop: 'color', value: 'black' }) + * root.nodes[0].nodes[1].raws.before //=> undefined + * root.nodes[0].nodes[1].raw('before') //=> ' ' + * ``` + * + * @param prop Name of code style property. + * @param defaultType Name of default value, it can be missed + * if the value is the same as prop. + * @return {string} Code style value. + */ + raw(prop: string, defaultType?: string): string + + /** + * It removes the node from its parent and deletes its parent property. + * + * ```js + * if (decl.prop.match(/^-webkit-/)) { + * decl.remove() + * } + * ``` + * + * @return `this` for method chaining. + */ + remove(): this + + /** + * Inserts node(s) before the current node and removes the current node. + * + * ```js + * AtRule: { + * mixin: atrule => { + * atrule.replaceWith(mixinRules[atrule.params]) + * } + * } + * ``` + * + * @param nodes Mode(s) to replace current one. + * @return Current node to methods chain. + */ + replaceWith(...nodes: NewChild[]): this + + /** + * Finds the Root instance of the node’s tree. + * + * ```js + * root.nodes[0].nodes[0].root() === root + * ``` + * + * @return Root parent. + */ + root(): Root + + /** + * Fix circular links on `JSON.stringify()`. + * + * @return Cleaned object. + */ + toJSON(): object + + /** + * It compiles the node to browser readable cascading style sheets string + * depending on it's type. + * + * ```js + * new Rule({ selector: 'a' }).toString() //=> "a {}" + * ``` + * + * @param stringifier A syntax to use in string generation. + * @return CSS string of this node. + */ + toString(stringifier?: Stringifier | Syntax): string + + /** + * It is a wrapper for {@link Result#warn}, providing convenient + * way of generating warnings. + * + * ```js + * Declaration: { + * bad: (decl, { result }) => { + * decl.warn(result, 'Deprecated property: bad') + * } + * } + * ``` + * + * @param result The `Result` instance that will receive the warning. + * @param message Description for the warning. + * @param options Options for the warning. + * + * @return `Warning` instance is returned + */ + warn(result: Result, message: string, options?: WarningOptions): Warning + + /** + * If this node isn't already dirty, marks it and its ancestors as such. This + * indicates to the LazyResult processor that the {@link Root} has been + * modified by the current plugin and may need to be processed again by other + * plugins. + */ + protected markDirty(): void +} + +declare class Node extends Node_ {} + +export = Node diff --git a/frontend/node_modules/postcss/lib/node.js b/frontend/node_modules/postcss/lib/node.js new file mode 100644 index 0000000..f249c35 --- /dev/null +++ b/frontend/node_modules/postcss/lib/node.js @@ -0,0 +1,456 @@ +'use strict' + +let CssSyntaxError = require('./css-syntax-error') +let Stringifier = require('./stringifier') +let stringify = require('./stringify') +let { isClean, my } = require('./symbols') + +function cloneNode(obj, parent) { + let cloned = new obj.constructor() + + for (let i in obj) { + if (!Object.prototype.hasOwnProperty.call(obj, i)) { + /* c8 ignore next 2 */ + continue + } + if (i === 'proxyCache') continue + let value = obj[i] + let type = typeof value + + if (i === 'parent' && type === 'object') { + if (parent) cloned[i] = parent + } else if (i === 'source') { + cloned[i] = value + } else if (Array.isArray(value)) { + cloned[i] = value.map(j => cloneNode(j, cloned)) + } else { + if (type === 'object' && value !== null) value = cloneNode(value) + cloned[i] = value + } + } + + return cloned +} + +function sourceOffset(inputCSS, position) { + // Not all custom syntaxes support `offset` in `source.start` and `source.end` + if (position && typeof position.offset !== 'undefined') { + return position.offset + } + + let column = 1 + let line = 1 + let offset = 0 + + for (let i = 0; i < inputCSS.length; i++) { + if (line === position.line && column === position.column) { + offset = i + break + } + + if (inputCSS[i] === '\n') { + column = 1 + line += 1 + } else { + column += 1 + } + } + + return offset +} + +class Node { + get proxyOf() { + return this + } + + constructor(defaults = {}) { + this.raws = {} + this[isClean] = false + this[my] = true + + for (let name in defaults) { + if (name === 'nodes') { + this.nodes = [] + for (let node of defaults[name]) { + // Clone only nodes that already belong to another tree, so passing a + // freshly created (parent-less) node adopts that instance instead of + // a copy and keeps the caller's reference usable. See #1987. + if (typeof node.clone === 'function' && node.parent) { + this.append(node.clone()) + } else { + this.append(node) + } + } + } else { + this[name] = defaults[name] + } + } + } + + addToError(error) { + error.postcssNode = this + if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) { + let s = this.source + error.stack = error.stack.replace( + /\n\s{4}at /, + `$&${s.input.from}:${s.start.line}:${s.start.column}$&` + ) + } + return error + } + + after(add) { + this.parent.insertAfter(this, add) + return this + } + + assign(overrides = {}) { + for (let name in overrides) { + this[name] = overrides[name] + } + return this + } + + before(add) { + this.parent.insertBefore(this, add) + return this + } + + cleanRaws(keepBetween) { + delete this.raws.before + delete this.raws.after + if (!keepBetween) delete this.raws.between + } + + clone(overrides = {}) { + let cloned = cloneNode(this) + for (let name in overrides) { + cloned[name] = overrides[name] + } + return cloned + } + + cloneAfter(overrides = {}) { + let cloned = this.clone(overrides) + this.parent.insertAfter(this, cloned) + return cloned + } + + cloneBefore(overrides = {}) { + let cloned = this.clone(overrides) + this.parent.insertBefore(this, cloned) + return cloned + } + + error(message, opts = {}) { + if (this.source) { + let { end, start } = this.rangeBy(opts) + return this.source.input.error( + message, + { column: start.column, line: start.line }, + { column: end.column, line: end.line }, + opts + ) + } + return new CssSyntaxError(message) + } + + getProxyProcessor() { + return { + get(node, prop) { + if (prop === 'proxyOf') { + return node + } else if (prop === 'root') { + return () => node.root().toProxy() + } else { + return node[prop] + } + }, + + set(node, prop, value) { + if (node[prop] === value) return true + node[prop] = value + if ( + prop === 'prop' || + prop === 'value' || + prop === 'name' || + prop === 'params' || + prop === 'important' || + /* c8 ignore next */ + prop === 'text' + ) { + node.markDirty() + } + return true + } + } + } + + /* c8 ignore next 3 */ + markClean() { + this[isClean] = true + } + + markDirty() { + if (this[isClean]) { + this[isClean] = false + let next = this + while ((next = next.parent)) { + next[isClean] = false + } + } + } + + next() { + if (!this.parent) return undefined + let index = this.parent.index(this) + return this.parent.nodes[index + 1] + } + + positionBy(opts = {}) { + let inputString = + 'document' in this.source.input + ? this.source.input.document + : this.source.input.css + let pos = { + column: this.source.start.column, + line: this.source.start.line, + offset: sourceOffset(inputString, this.source.start) + } + if (opts.index) { + pos = this.positionInside(opts.index) + } else if (opts.word) { + let stringRepresentation = inputString.slice( + sourceOffset(inputString, this.source.start), + sourceOffset(inputString, this.source.end) + ) + let index = stringRepresentation.indexOf(opts.word) + if (index !== -1) pos = this.positionInside(index) + } + return pos + } + + positionInside(index) { + let column = this.source.start.column + let line = this.source.start.line + let inputString = + 'document' in this.source.input + ? this.source.input.document + : this.source.input.css + let offset = sourceOffset(inputString, this.source.start) + let end = offset + index + + for (let i = offset; i < end; i++) { + if (inputString[i] === '\n') { + column = 1 + line += 1 + } else { + column += 1 + } + } + + return { column, line, offset: end } + } + + prev() { + if (!this.parent) return undefined + let index = this.parent.index(this) + return this.parent.nodes[index - 1] + } + + rangeBy(opts = {}) { + let inputString = + 'document' in this.source.input + ? this.source.input.document + : this.source.input.css + let start = { + column: this.source.start.column, + line: this.source.start.line, + offset: sourceOffset(inputString, this.source.start) + } + let end = this.source.end + ? { + column: this.source.end.column + 1, + line: this.source.end.line, + offset: + typeof this.source.end.offset === 'number' + ? // `source.end.offset` is exclusive, so we don't need to add 1 + this.source.end.offset + : // Since line/column in this.source.end is inclusive, + // the `sourceOffset(... , this.source.end)` returns an inclusive offset. + // So, we add 1 to convert it to exclusive. + sourceOffset(inputString, this.source.end) + 1 + } + : { + column: start.column + 1, + line: start.line, + offset: start.offset + 1 + } + + if (opts.word) { + let stringRepresentation = inputString.slice( + sourceOffset(inputString, this.source.start), + sourceOffset(inputString, this.source.end) + ) + let index = stringRepresentation.indexOf(opts.word) + if (index !== -1) { + start = this.positionInside(index) + end = this.positionInside(index + opts.word.length) + } + } else { + if (opts.start) { + start = { + column: opts.start.column, + line: opts.start.line, + offset: sourceOffset(inputString, opts.start) + } + } else if (typeof opts.index === 'number') { + start = this.positionInside(opts.index) + } + + if (opts.end) { + end = { + column: opts.end.column, + line: opts.end.line, + offset: sourceOffset(inputString, opts.end) + } + } else if (typeof opts.endIndex === 'number') { + end = this.positionInside(opts.endIndex) + } else if (typeof opts.index === 'number') { + end = this.positionInside(opts.index + 1) + } + } + + if ( + end.line < start.line || + (end.line === start.line && end.column <= start.column) + ) { + end = { + column: start.column + 1, + line: start.line, + offset: start.offset + 1 + } + } + + return { end, start } + } + + raw(prop, defaultType) { + let str = new Stringifier() + return str.raw(this, prop, defaultType) + } + + remove() { + if (this.parent) { + this.parent.removeChild(this) + } + this.parent = undefined + return this + } + + replaceWith(...nodes) { + if (this.parent) { + let bookmark = this + let foundSelf = false + for (let node of nodes) { + if (node === this) { + foundSelf = true + } else if (foundSelf) { + this.parent.insertAfter(bookmark, node) + bookmark = node + } else { + this.parent.insertBefore(bookmark, node) + } + } + + if (!foundSelf) { + this.remove() + } + } + + return this + } + + root() { + let result = this + while (result.parent && result.parent.type !== 'document') { + result = result.parent + } + return result + } + + toJSON(_, inputs) { + let fixed = {} + let emitInputs = inputs == null + inputs = inputs || new Map() + let inputsNextIndex = 0 + + for (let name in this) { + if (!Object.prototype.hasOwnProperty.call(this, name)) { + /* c8 ignore next 2 */ + continue + } + if (name === 'parent' || name === 'proxyCache') continue + let value = this[name] + + if (Array.isArray(value)) { + fixed[name] = value.map(i => { + if (typeof i === 'object' && i.toJSON) { + return i.toJSON(null, inputs) + } else { + return i + } + }) + } else if (typeof value === 'object' && value.toJSON) { + fixed[name] = value.toJSON(null, inputs) + } else if (name === 'source') { + if (value == null) continue + let inputId = inputs.get(value.input) + if (inputId == null) { + inputId = inputsNextIndex + inputs.set(value.input, inputsNextIndex) + inputsNextIndex++ + } + fixed[name] = { + end: value.end, + inputId, + start: value.start + } + } else { + fixed[name] = value + } + } + + if (emitInputs) { + fixed.inputs = [...inputs.keys()].map(input => input.toJSON()) + } + + return fixed + } + + toProxy() { + if (!this.proxyCache) { + this.proxyCache = new Proxy(this, this.getProxyProcessor()) + } + return this.proxyCache + } + + toString(stringifier = stringify) { + if (stringifier.stringify) stringifier = stringifier.stringify + let result = '' + stringifier(this, i => { + result += i + }) + return result + } + + warn(result, text, opts = {}) { + let data = { node: this } + for (let i in opts) data[i] = opts[i] + return result.warn(text, data) + } +} + +module.exports = Node +Node.default = Node diff --git a/frontend/node_modules/postcss/lib/parse.d.ts b/frontend/node_modules/postcss/lib/parse.d.ts new file mode 100644 index 0000000..ffe35b4 --- /dev/null +++ b/frontend/node_modules/postcss/lib/parse.d.ts @@ -0,0 +1,9 @@ +import { Parser } from './postcss.js' + +interface Parse extends Parser { + default: Parse +} + +declare let parse: Parse + +export = parse diff --git a/frontend/node_modules/postcss/lib/parse.js b/frontend/node_modules/postcss/lib/parse.js new file mode 100644 index 0000000..00a1037 --- /dev/null +++ b/frontend/node_modules/postcss/lib/parse.js @@ -0,0 +1,42 @@ +'use strict' + +let Container = require('./container') +let Input = require('./input') +let Parser = require('./parser') + +function parse(css, opts) { + let input = new Input(css, opts) + let parser = new Parser(input) + try { + parser.parse() + } catch (e) { + if (process.env.NODE_ENV !== 'production') { + if (e.name === 'CssSyntaxError' && opts && opts.from) { + if (/\.scss$/i.test(opts.from)) { + e.message += + '\nYou tried to parse SCSS with ' + + 'the standard CSS parser; ' + + 'try again with the postcss-scss parser' + } else if (/\.sass/i.test(opts.from)) { + e.message += + '\nYou tried to parse Sass with ' + + 'the standard CSS parser; ' + + 'try again with the postcss-sass parser' + } else if (/\.less$/i.test(opts.from)) { + e.message += + '\nYou tried to parse Less with ' + + 'the standard CSS parser; ' + + 'try again with the postcss-less parser' + } + } + } + throw e + } + + return parser.root +} + +module.exports = parse +parse.default = parse + +Container.registerParse(parse) diff --git a/frontend/node_modules/postcss/lib/parser.js b/frontend/node_modules/postcss/lib/parser.js new file mode 100644 index 0000000..2a16584 --- /dev/null +++ b/frontend/node_modules/postcss/lib/parser.js @@ -0,0 +1,618 @@ +'use strict' + +let AtRule = require('./at-rule') +let Comment = require('./comment') +let Declaration = require('./declaration') +let Root = require('./root') +let Rule = require('./rule') +let tokenizer = require('./tokenize') + +const SAFE_COMMENT_NEIGHBOR = { + empty: true, + space: true +} + +function findLastWithPosition(tokens) { + for (let i = tokens.length - 1; i >= 0; i--) { + let token = tokens[i] + let pos = token[3] || token[2] + if (pos) return pos + } +} + +function tokensToString(tokens, from, to) { + let result = '' + for (let i = from; i < to; i++) result += tokens[i][1] + return result +} + +class Parser { + constructor(input) { + this.input = input + + this.root = new Root() + this.current = this.root + this.spaces = '' + this.semicolon = false + + this.createTokenizer() + this.root.source = { input, start: { column: 1, line: 1, offset: 0 } } + } + + atrule(token) { + let node = new AtRule() + node.name = token[1].slice(1) + if (node.name === '') { + this.unnamedAtrule(node, token) + } + this.init(node, token[2]) + + let type + let prev + let shift + let last = false + let open = false + let params = [] + let brackets = [] + + while (!this.tokenizer.endOfFile()) { + token = this.tokenizer.nextToken() + type = token[0] + + if (type === '(' || type === '[') { + brackets.push(type === '(' ? ')' : ']') + } else if (type === '{' && brackets.length > 0) { + brackets.push('}') + } else if (type === brackets[brackets.length - 1]) { + brackets.pop() + } + + if (brackets.length === 0) { + if (type === ';') { + node.source.end = this.getPosition(token[2]) + node.source.end.offset++ + this.semicolon = true + break + } else if (type === '{') { + open = true + break + } else if (type === '}') { + if (params.length > 0) { + shift = params.length - 1 + prev = params[shift] + while (prev && prev[0] === 'space') { + prev = params[--shift] + } + if (prev) { + node.source.end = this.getPosition(prev[3] || prev[2]) + node.source.end.offset++ + } + } + this.end(token) + break + } else { + params.push(token) + } + } else { + params.push(token) + } + + if (this.tokenizer.endOfFile()) { + last = true + break + } + } + + node.raws.between = this.spacesAndCommentsFromEnd(params) + if (params.length) { + node.raws.afterName = this.spacesAndCommentsFromStart(params) + this.raw(node, 'params', params) + if (last) { + token = params[params.length - 1] + node.source.end = this.getPosition(token[3] || token[2]) + node.source.end.offset++ + this.spaces = node.raws.between + node.raws.between = '' + } + } else { + node.raws.afterName = '' + node.params = '' + } + + if (open) { + node.nodes = [] + this.current = node + } + } + + checkMissedSemicolon(tokens) { + let colon = this.colon(tokens) + if (colon === false) return + + let founded = 0 + let token + for (let j = colon - 1; j >= 0; j--) { + token = tokens[j] + if (token[0] !== 'space') { + founded += 1 + if (founded === 2) break + } + } + // If the token is a word, e.g. `!important`, `red` or any other valid + // property's value. Then we need to return the colon after that word + // token. [3] is the "end" colon of that word. And because we need it + // after that one we do +1 to get the next one. + throw this.input.error( + 'Missed semicolon', + token[0] === 'word' ? token[3] + 1 : token[2] + ) + } + + colon(tokens) { + let brackets = 0 + let prev, token, type + for (let [i, element] of tokens.entries()) { + token = element + type = token[0] + + if (type === '(') { + brackets += 1 + } + if (type === ')') { + brackets -= 1 + } + if (brackets === 0 && type === ':') { + if (!prev) { + this.doubleColon(token) + } else if (prev[0] === 'word' && prev[1] === 'progid') { + continue + } else { + return i + } + } + + prev = token + } + return false + } + + comment(token) { + let node = new Comment() + this.init(node, token[2]) + node.source.end = this.getPosition(token[3] || token[2]) + node.source.end.offset++ + + let text = token[1].slice(2, -2) + if (!text.trim()) { + node.text = '' + node.raws.left = text + node.raws.right = '' + } else { + let match = text.match(/^(\s*)([^]*\S)(\s*)$/) + node.text = match[2] + node.raws.left = match[1] + node.raws.right = match[3] + } + } + + createTokenizer() { + this.tokenizer = tokenizer(this.input) + } + + decl(tokens, customProperty) { + let node = new Declaration() + this.init(node, tokens[0][2]) + + let last = tokens[tokens.length - 1] + if (last[0] === ';') { + this.semicolon = true + tokens.pop() + } + + node.source.end = this.getPosition( + last[3] || last[2] || findLastWithPosition(tokens) + ) + node.source.end.offset++ + + let start = 0 + while (tokens[start][0] !== 'word') { + if (start === tokens.length - 1) this.unknownWord([tokens[start]]) + start++ + } + node.raws.before += tokensToString(tokens, 0, start) + node.source.start = this.getPosition(tokens[start][2]) + + let propStart = start + while (start < tokens.length) { + let type = tokens[start][0] + if (type === ':' || type === 'space' || type === 'comment') { + break + } + start++ + } + node.prop = tokensToString(tokens, propStart, start) + + let betweenStart = start + let token + while (start < tokens.length) { + token = tokens[start] + start++ + if (token[0] === ':') break + if (token[0] === 'word' && /\w/.test(token[1])) { + this.unknownWord([token]) + } + } + node.raws.between = tokensToString(tokens, betweenStart, start) + + if (node.prop[0] === '_' || node.prop[0] === '*') { + node.raws.before += node.prop[0] + node.prop = node.prop.slice(1) + } + + let firstSpacesStart = start + while (start < tokens.length) { + let next = tokens[start][0] + if (next !== 'space' && next !== 'comment') break + start++ + } + let firstSpaces = tokens.slice(firstSpacesStart, start) + + tokens = tokens.slice(start) + + this.precheckMissedSemicolon(tokens) + + for (let i = tokens.length - 1; i >= 0; i--) { + token = tokens[i] + if (token[1].toLowerCase() === '!important') { + node.important = true + let string = this.stringFrom(tokens, i) + string = this.spacesFromEnd(tokens) + string + if (string !== ' !important') node.raws.important = string + break + } else if (token[1].toLowerCase() === 'important') { + let cache = tokens.slice(0) + let str = '' + for (let j = i; j > 0; j--) { + let type = cache[j][0] + if (str.trim().startsWith('!') && type !== 'space') { + break + } + str = cache.pop()[1] + str + } + if (str.trim().startsWith('!')) { + node.important = true + node.raws.important = str + tokens = cache + } + } + + if (token[0] !== 'space' && token[0] !== 'comment') { + break + } + } + + let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment') + + if (hasWord) { + node.raws.between += firstSpaces.map(i => i[1]).join('') + firstSpaces = [] + } + this.raw(node, 'value', firstSpaces.concat(tokens), customProperty) + + if (node.value.includes(':') && !customProperty) { + this.checkMissedSemicolon(tokens) + } + } + + doubleColon(token) { + throw this.input.error( + 'Double colon', + { offset: token[2] }, + { offset: token[2] + token[1].length } + ) + } + + emptyRule(token) { + let node = new Rule() + this.init(node, token[2]) + node.selector = '' + node.raws.between = '' + this.current = node + } + + end(token) { + if (this.current.nodes && this.current.nodes.length) { + this.current.raws.semicolon = this.semicolon + } + this.semicolon = false + + this.current.raws.after = (this.current.raws.after || '') + this.spaces + this.spaces = '' + + if (this.current.parent) { + this.current.source.end = this.getPosition(token[2]) + this.current.source.end.offset++ + this.current = this.current.parent + } else { + this.unexpectedClose(token) + } + } + + endFile() { + if (this.current.parent) this.unclosedBlock() + if (this.current.nodes && this.current.nodes.length) { + this.current.raws.semicolon = this.semicolon + } + this.current.raws.after = (this.current.raws.after || '') + this.spaces + this.root.source.end = this.getPosition(this.tokenizer.position()) + } + + freeSemicolon(token) { + this.spaces += token[1] + if (this.current.nodes) { + let prev = this.current.nodes[this.current.nodes.length - 1] + if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) { + prev.raws.ownSemicolon = this.spaces + this.spaces = '' + prev.source.end = this.getPosition(token[2]) + prev.source.end.offset += prev.raws.ownSemicolon.length + } + } + } + + // Helpers + + getPosition(offset) { + let pos = this.input.fromOffset(offset) + return { + column: pos.col, + line: pos.line, + offset + } + } + + init(node, offset) { + this.current.push(node) + node.source = { + input: this.input, + start: this.getPosition(offset) + } + node.raws.before = this.spaces + this.spaces = '' + if (node.type !== 'comment') this.semicolon = false + } + + other(start) { + let end = false + let type = null + let colon = false + let bracket = null + let brackets = [] + let customProperty = start[1].startsWith('--') + + let tokens = [] + let token = start + while (token) { + type = token[0] + tokens.push(token) + + if (type === '(' || type === '[') { + if (!bracket) bracket = token + brackets.push(type === '(' ? ')' : ']') + } else if (customProperty && colon && type === '{') { + if (!bracket) bracket = token + brackets.push('}') + } else if (brackets.length === 0) { + if (type === ';') { + if (colon) { + this.decl(tokens, customProperty) + return + } else { + break + } + } else if (type === '{') { + this.rule(tokens) + return + } else if (type === '}') { + this.tokenizer.back(tokens.pop()) + end = true + break + } else if (type === ':') { + colon = true + } + } else if (type === brackets[brackets.length - 1]) { + brackets.pop() + if (brackets.length === 0) bracket = null + } + + token = this.tokenizer.nextToken() + } + + if (this.tokenizer.endOfFile()) end = true + if (brackets.length > 0) this.unclosedBracket(bracket) + + if (end && colon) { + if (!customProperty) { + while (tokens.length) { + token = tokens[tokens.length - 1][0] + if (token !== 'space' && token !== 'comment') break + this.tokenizer.back(tokens.pop()) + } + } + this.decl(tokens, customProperty) + } else { + this.unknownWord(tokens) + } + } + + parse() { + let token + while (!this.tokenizer.endOfFile()) { + token = this.tokenizer.nextToken() + + switch (token[0]) { + case 'space': + this.spaces += token[1] + break + + case ';': + this.freeSemicolon(token) + break + + case '}': + this.end(token) + break + + case 'comment': + this.comment(token) + break + + case 'at-word': + this.atrule(token) + break + + case '{': + this.emptyRule(token) + break + + default: + this.other(token) + break + } + } + this.endFile() + } + + precheckMissedSemicolon(/* tokens */) { + // Hook for Safe Parser + } + + raw(node, prop, tokens, customProperty) { + let token, type + let length = tokens.length + let value = '' + let clean = true + let next, prev + + for (let i = 0; i < length; i += 1) { + token = tokens[i] + type = token[0] + if (type === 'space' && i === length - 1 && !customProperty) { + clean = false + } else if (type === 'comment') { + prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty' + next = tokens[i + 1] ? tokens[i + 1][0] : 'empty' + if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) { + if (value.slice(-1) === ',') { + clean = false + } else { + value += token[1] + } + } else { + clean = false + } + } else { + value += token[1] + } + } + if (!clean) { + let raw = tokens.reduce((all, i) => all + i[1], '') + node.raws[prop] = { raw, value } + } + node[prop] = value + } + + rule(tokens) { + tokens.pop() + + let node = new Rule() + this.init(node, tokens[0][2]) + + node.raws.between = this.spacesAndCommentsFromEnd(tokens) + this.raw(node, 'selector', tokens) + this.current = node + } + + spacesAndCommentsFromEnd(tokens) { + let lastTokenType + let spaces = '' + while (tokens.length) { + lastTokenType = tokens[tokens.length - 1][0] + if (lastTokenType !== 'space' && lastTokenType !== 'comment') break + spaces = tokens.pop()[1] + spaces + } + return spaces + } + + // Errors + + spacesAndCommentsFromStart(tokens) { + let next + let spaces = '' + while (tokens.length) { + next = tokens[0][0] + if (next !== 'space' && next !== 'comment') break + spaces += tokens.shift()[1] + } + return spaces + } + + spacesFromEnd(tokens) { + let lastTokenType + let spaces = '' + while (tokens.length) { + lastTokenType = tokens[tokens.length - 1][0] + if (lastTokenType !== 'space') break + spaces = tokens.pop()[1] + spaces + } + return spaces + } + + stringFrom(tokens, from) { + let result = '' + for (let i = from; i < tokens.length; i++) { + result += tokens[i][1] + } + tokens.splice(from, tokens.length - from) + return result + } + + unclosedBlock() { + let pos = this.current.source.start + throw this.input.error('Unclosed block', pos.line, pos.column) + } + + unclosedBracket(bracket) { + throw this.input.error( + 'Unclosed bracket', + { offset: bracket[2] }, + { offset: bracket[2] + 1 } + ) + } + + unexpectedClose(token) { + throw this.input.error( + 'Unexpected }', + { offset: token[2] }, + { offset: token[2] + 1 } + ) + } + + unknownWord(tokens) { + throw this.input.error( + 'Unknown word ' + tokens[0][1], + { offset: tokens[0][2] }, + { offset: tokens[0][2] + tokens[0][1].length } + ) + } + + unnamedAtrule(node, token) { + throw this.input.error( + 'At-rule without name', + { offset: token[2] }, + { offset: token[2] + token[1].length } + ) + } +} + +module.exports = Parser diff --git a/frontend/node_modules/postcss/lib/postcss.d.mts b/frontend/node_modules/postcss/lib/postcss.d.mts new file mode 100644 index 0000000..eaec868 --- /dev/null +++ b/frontend/node_modules/postcss/lib/postcss.d.mts @@ -0,0 +1,66 @@ +export { + // Type-only exports + AcceptedPlugin, + AnyNode, + atRule, + AtRule, + AtRuleProps, + Builder, + ChildNode, + ChildProps, + comment, + Comment, + CommentProps, + Container, + ContainerProps, + CssSyntaxError, + decl, + Declaration, + DeclarationProps, + // postcss function / namespace + default, + document, + Document, + DocumentProps, + FilePosition, + fromJSON, + Helpers, + Input, + JSONHydrator, + // This is a class, but it’s not re-exported. That’s why it’s exported as type-only here. + type LazyResult, + list, + Message, + Node, + NodeErrorOptions, + NodeProps, + OldPlugin, + parse, + Parser, + // @ts-expect-error This value exists, but it’s untyped. + plugin, + Plugin, + PluginCreator, + Position, + Postcss, + ProcessOptions, + Processor, + Result, + root, + Root, + RootProps, + rule, + Rule, + RuleProps, + Source, + SourceMap, + SourceMapOptions, + Stringifier, + // Value exports from postcss.mjs + stringify, + Syntax, + TransformCallback, + Transformer, + Warning, + WarningOptions +} from './postcss.js' diff --git a/frontend/node_modules/postcss/lib/postcss.d.ts b/frontend/node_modules/postcss/lib/postcss.d.ts new file mode 100644 index 0000000..667d820 --- /dev/null +++ b/frontend/node_modules/postcss/lib/postcss.d.ts @@ -0,0 +1,461 @@ +import { RawSourceMap, SourceMapGenerator } from 'source-map-js' + +import AtRule, { AtRuleProps } from './at-rule.js' +import Comment, { CommentProps } from './comment.js' +import Container, { ContainerProps, NewChild } from './container.js' +import CssSyntaxError from './css-syntax-error.js' +import Declaration, { DeclarationProps } from './declaration.js' +import Document, { DocumentProps } from './document.js' +import Input, { FilePosition } from './input.js' +import LazyResult from './lazy-result.js' +import list from './list.js' +import Node, { + AnyNode, + ChildNode, + ChildProps, + NodeErrorOptions, + NodeProps, + Position, + Source +} from './node.js' +import Processor from './processor.js' +import Result, { Message } from './result.js' +import Root, { RootProps } from './root.js' +import Rule, { RuleProps } from './rule.js' +import Warning, { WarningOptions } from './warning.js' + +type DocumentProcessor = ( + document: Document, + helper: postcss.Helpers +) => Promise | void +type RootProcessor = ( + root: Root, + helper: postcss.Helpers +) => Promise | void +type DeclarationProcessor = ( + decl: Declaration, + helper: postcss.Helpers +) => Promise | void +type RuleProcessor = ( + rule: Rule, + helper: postcss.Helpers +) => Promise | void +type AtRuleProcessor = ( + atRule: AtRule, + helper: postcss.Helpers +) => Promise | void +type CommentProcessor = ( + comment: Comment, + helper: postcss.Helpers +) => Promise | void + +interface Processors { + /** + * Will be called on all`AtRule` nodes. + * + * Will be called again on node or children changes. + */ + AtRule?: { [name: string]: AtRuleProcessor } | AtRuleProcessor + + /** + * Will be called on all `AtRule` nodes, when all children will be processed. + * + * Will be called again on node or children changes. + */ + AtRuleExit?: { [name: string]: AtRuleProcessor } | AtRuleProcessor + + /** + * Will be called on all `Comment` nodes. + * + * Will be called again on node or children changes. + */ + Comment?: CommentProcessor + + /** + * Will be called on all `Comment` nodes after listeners + * for `Comment` event. + * + * Will be called again on node or children changes. + */ + CommentExit?: CommentProcessor + + /** + * Will be called on all `Declaration` nodes after listeners + * for `Declaration` event. + * + * Will be called again on node or children changes. + */ + Declaration?: { [prop: string]: DeclarationProcessor } | DeclarationProcessor + + /** + * Will be called on all `Declaration` nodes. + * + * Will be called again on node or children changes. + */ + DeclarationExit?: + | { [prop: string]: DeclarationProcessor } + | DeclarationProcessor + + /** + * Will be called on `Document` node. + * + * Will be called again on children changes. + */ + Document?: DocumentProcessor + + /** + * Will be called on `Document` node, when all children will be processed. + * + * Will be called again on children changes. + */ + DocumentExit?: DocumentProcessor + + /** + * Will be called on `Root` node once. + */ + Once?: RootProcessor + + /** + * Will be called on `Root` node once, when all children will be processed. + */ + OnceExit?: RootProcessor + + /** + * Will be called on `Root` node. + * + * Will be called again on children changes. + */ + Root?: RootProcessor + + /** + * Will be called on `Root` node, when all children will be processed. + * + * Will be called again on children changes. + */ + RootExit?: RootProcessor + + /** + * Will be called on all `Rule` nodes. + * + * Will be called again on node or children changes. + */ + Rule?: RuleProcessor + + /** + * Will be called on all `Rule` nodes, when all children will be processed. + * + * Will be called again on node or children changes. + */ + RuleExit?: RuleProcessor +} + +declare namespace postcss { + export { + AnyNode, + AtRule, + AtRuleProps, + ChildNode, + ChildProps, + Comment, + CommentProps, + Container, + ContainerProps, + CssSyntaxError, + Declaration, + DeclarationProps, + Document, + DocumentProps, + FilePosition, + Input, + LazyResult, + list, + Message, + NewChild, + Node, + NodeErrorOptions, + NodeProps, + Position, + Processor, + Result, + Root, + RootProps, + Rule, + RuleProps, + Source, + Warning, + WarningOptions + } + + export type SourceMap = { + toJSON(): RawSourceMap + } & SourceMapGenerator + + export type Helpers = { postcss: Postcss; result: Result } & Postcss + + export interface Plugin extends Processors { + postcssPlugin: string + prepare?: (result: Result) => Processors + } + + export interface PluginCreator { + (opts?: PluginOptions): Plugin | Processor + postcss: true + } + + export interface Transformer extends TransformCallback { + postcssPlugin: string + postcssVersion: string + } + + export interface TransformCallback { + (root: Root, result: Result): Promise | void + } + + export interface OldPlugin extends Transformer { + (opts?: T): Transformer + postcss: Transformer + } + + export type AcceptedPlugin = + | { + postcss: Processor | TransformCallback + } + | OldPlugin + | Plugin + | PluginCreator + | Processor + | TransformCallback + + export interface Parser { + ( + css: { toString(): string } | string, + opts?: Pick + ): RootNode + } + + export interface Builder { + (part: string, node?: AnyNode, type?: 'end' | 'start'): void + } + + export interface Stringifier { + (node: AnyNode, builder: Builder): void + } + + export interface JSONHydrator { + (data: object): Node + (data: object[]): Node[] + } + + export interface Syntax { + /** + * Function to generate AST by string. + */ + parse?: Parser + + /** + * Class to generate string by AST. + */ + stringify?: Stringifier + } + + export interface SourceMapOptions { + /** + * Use absolute path in generated source map. + */ + absolute?: boolean + + /** + * Indicates that PostCSS should add annotation comments to the CSS. + * By default, PostCSS will always add a comment with a path + * to the source map. PostCSS will not add annotations to CSS files + * that do not contain any comments. + * + * By default, PostCSS presumes that you want to save the source map as + * `opts.to + '.map'` and will use this path in the annotation comment. + * A different path can be set by providing a string value for annotation. + * + * If you have set `inline: true`, annotation cannot be disabled. + */ + annotation?: ((file: string, root: Root) => string) | boolean | string + + /** + * Override `from` in map’s sources. + */ + from?: string + + /** + * Indicates that the source map should be embedded in the output CSS + * as a Base64-encoded comment. By default, it is `true`. + * But if all previous maps are external, not inline, PostCSS will not embed + * the map even if you do not set this option. + * + * If you have an inline source map, the result.map property will be empty, + * as the source map will be contained within the text of `result.css`. + */ + inline?: boolean + + /** + * Source map content from a previous processing step (e.g., Sass). + * + * PostCSS will try to read the previous source map + * automatically (based on comments within the source CSS), but you can use + * this option to identify it manually. + * + * If desired, you can omit the previous map with prev: `false`. + */ + prev?: ((file: string) => string) | boolean | object | string + + /** + * Indicates that PostCSS should set the origin content (e.g., Sass source) + * of the source map. By default, it is true. But if all previous maps do not + * contain sources content, PostCSS will also leave it out even if you + * do not set this option. + */ + sourcesContent?: boolean + } + + export interface ProcessOptions { + /** + * Input file if it is not simple CSS file, but HTML with + + `; +} +//#endregion +//#region src/node/server/transformRequest.ts +const ERR_LOAD_URL = "ERR_LOAD_URL"; +const ERR_LOAD_PUBLIC_URL = "ERR_LOAD_PUBLIC_URL"; +const ERR_DENIED_ID = "ERR_DENIED_ID"; +const debugLoad = createDebugger("vite:load"); +const debugTransform = createDebugger("vite:transform"); +const debugCache$1 = createDebugger("vite:cache"); +function transformRequest(environment, url, options) { + if (environment._closing && environment.config.dev.recoverable) throwClosedServerError(); + const timestamp = monotonicDateNow(); + url = removeTimestampQuery(url); + const pending = environment._pendingRequests.get(url); + if (pending) return environment.moduleGraph.getModuleByUrl(url).then((module) => { + if (!module || pending.timestamp > module.lastInvalidationTimestamp) return pending.request; + else { + pending.abort(); + return transformRequest(environment, url, options); + } + }); + const request = doTransform(environment, url, options, timestamp); + let cleared = false; + const clearCache = () => { + if (!cleared) { + environment._pendingRequests.delete(url); + cleared = true; + } + }; + environment._pendingRequests.set(url, { + request, + timestamp, + abort: clearCache + }); + return request.finally(clearCache); +} +async function doTransform(environment, url, options, timestamp) { + const { pluginContainer } = environment; + let module = await environment.moduleGraph.getModuleByUrl(url); + if (module) { + const cached = await getCachedTransformResult(environment, url, module, timestamp); + if (cached) return cached; + } + const resolved = module ? void 0 : await pluginContainer.resolveId(url, void 0) ?? void 0; + const id = module?.id ?? resolved?.id ?? url; + module ??= environment.moduleGraph.getModuleById(id); + if (module) { + await environment.moduleGraph._ensureEntryFromUrl(url, void 0, resolved); + const cached = await getCachedTransformResult(environment, url, module, timestamp); + if (cached) return cached; + } + const result = loadAndTransform(environment, id, url, options, timestamp, module, resolved); + const { depsOptimizer } = environment; + if (!depsOptimizer?.isOptimizedDepFile(id)) environment._registerRequestProcessing(id, () => result); + return result; +} +async function getCachedTransformResult(environment, url, module, timestamp) { + const prettyUrl = debugCache$1 ? prettifyUrl(url, environment.config.root) : ""; + const softInvalidatedTransformResult = await handleModuleSoftInvalidation(environment, module, timestamp); + if (softInvalidatedTransformResult) { + debugCache$1?.(`[memory-hmr] ${prettyUrl}`); + return softInvalidatedTransformResult; + } + const cached = module.transformResult; + if (cached) { + debugCache$1?.(`[memory] ${prettyUrl}`); + return cached; + } +} +async function loadAndTransform(environment, id, url, options, timestamp, mod, resolved) { + const { config, pluginContainer, logger } = environment; + const prettyUrl = debugLoad || debugTransform ? prettifyUrl(url, config.root) : ""; + const moduleGraph = environment.moduleGraph; + if (!options.skipFsCheck && id[0] !== "\0" && isServerAccessDeniedForTransform(config, id)) { + const err = /* @__PURE__ */ new Error(`Denied ID ${id}`); + err.code = ERR_DENIED_ID; + err.id = id; + throw err; + } + let code = null; + let map = null; + let moduleType; + const loadStart = debugLoad ? performance$1.now() : 0; + const loadResult = await pluginContainer.load(id); + if (loadResult == null) { + const file = cleanUrl(id); + if (options.skipFsCheck || isFileLoadingAllowed(environment.getTopLevelConfig(), slash(file))) { + try { + code = await fsp.readFile(file, "utf-8"); + debugLoad?.(`${timeFrom(loadStart)} [fs] ${prettyUrl}`); + } catch (e) { + if (e.code !== "ENOENT" && e.code !== "EISDIR") throw e; + } + if (code != null && environment.pluginContainer.watcher) ensureWatchedFile(environment.pluginContainer.watcher, file, config.root); + } + if (code) try { + const extracted = extractSourcemapFromFile(code, file, logger); + if (extracted) { + code = extracted.code; + map = extracted.map; + } + } catch (e) { + logger.warn(`Failed to load source map for ${file}.\n${e}`, { timestamp: true }); + } + } else { + debugLoad?.(`${timeFrom(loadStart)} [plugin] ${prettyUrl}`); + if (isObject$1(loadResult)) { + code = loadResult.code; + map = loadResult.map; + moduleType = loadResult.moduleType; + } else code = loadResult; + } + if (code == null) { + const isPublicFile = checkPublicFile(url, environment.getTopLevelConfig()); + let publicDirName = path.relative(config.root, config.publicDir); + if (publicDirName[0] !== ".") publicDirName = "/" + publicDirName; + const msg = isPublicFile ? `This file is in ${publicDirName} and will be copied as-is during build without going through the plugin transforms, and therefore should not be imported from source code. It can only be referenced via HTML tags.` : `Does the file exist?`; + const importerMod = moduleGraph.idToModuleMap.get(id)?.importers.values().next().value; + const importer = importerMod?.file || importerMod?.url; + const err = /* @__PURE__ */ new Error(`Failed to load url ${url} (resolved id: ${id})${importer ? ` in ${importer}` : ""}. ${msg}`); + err.code = isPublicFile ? ERR_LOAD_PUBLIC_URL : ERR_LOAD_URL; + throw err; + } + if (moduleType === void 0) { + const guessedModuleType = getModuleTypeFromId(id); + if (guessedModuleType && guessedModuleType !== "js") moduleType = guessedModuleType; + } + if (environment._closing && environment.config.dev.recoverable) throwClosedServerError(); + mod ??= await moduleGraph._ensureEntryFromUrl(url, void 0, resolved); + const transformStart = debugTransform ? performance$1.now() : 0; + const transformResult = await pluginContainer.transform(code, id, { + inMap: map, + moduleType + }); + const originalCode = code; + if (transformResult.code === originalCode) debugTransform?.(timeFrom(transformStart) + import_picocolors.default.dim(` [skipped] ${prettyUrl}`)); + else { + debugTransform?.(`${timeFrom(transformStart)} ${prettyUrl}`); + code = transformResult.code; + map = transformResult.map; + } + let normalizedMap; + if (typeof map === "string") normalizedMap = JSON.parse(map); + else if (map) normalizedMap = map; + else normalizedMap = null; + if (normalizedMap && "version" in normalizedMap && mod.file) { + if (normalizedMap.mappings) await injectSourcesContent(normalizedMap, mod.file, logger); + const sourcemapPath = `${mod.file}.map`; + applySourcemapIgnoreList(normalizedMap, sourcemapPath, config.server.sourcemapIgnoreList, logger); + if (path.isAbsolute(mod.file)) { + let modDirname; + for (let sourcesIndex = 0; sourcesIndex < normalizedMap.sources.length; ++sourcesIndex) { + const sourcePath = normalizedMap.sources[sourcesIndex]; + if (sourcePath) { + if (path.isAbsolute(sourcePath)) { + modDirname ??= path.dirname(mod.file); + normalizedMap.sources[sourcesIndex] = path.relative(modDirname, sourcePath); + } + } + } + } + } + if (environment._closing && environment.config.dev.recoverable) throwClosedServerError(); + const topLevelConfig = environment.getTopLevelConfig(); + const result = environment.config.dev.moduleRunnerTransform ? await ssrTransform(code, normalizedMap, url, originalCode, { json: { stringify: topLevelConfig.json.stringify === true && topLevelConfig.json.namedExports !== true } }) : { + code, + map: normalizedMap, + etag: (0, import_etag.default)(code, { weak: true }) + }; + if (timestamp > mod.lastInvalidationTimestamp) moduleGraph.updateModuleTransformResult(mod, result); + return result; +} +/** +* When a module is soft-invalidated, we can preserve its previous `transformResult` and +* return similar code to before: +* +* - Client: We need to transform the import specifiers with new timestamps +* - SSR: We don't need to change anything as `ssrLoadModule` controls it +*/ +async function handleModuleSoftInvalidation(environment, mod, timestamp) { + const transformResult = mod.invalidationState; + mod.invalidationState = void 0; + if (!transformResult || transformResult === "HARD_INVALIDATED") return; + if (mod.transformResult) throw new Error(`Internal server error: Soft-invalidated module "${mod.url}" should not have existing transform result`); + let result; + if (transformResult.ssr) result = transformResult; + else { + await init; + const source = transformResult.code; + const s = new MagicString(source); + const [imports] = parse$2(source, mod.id || void 0); + for (const imp of imports) { + let rawUrl = source.slice(imp.s, imp.e); + if (rawUrl === "import.meta") continue; + const hasQuotes = rawUrl[0] === "\"" || rawUrl[0] === "'"; + if (hasQuotes) rawUrl = rawUrl.slice(1, -1); + const urlWithoutTimestamp = removeTimestampQuery(rawUrl); + const hmrUrl = unwrapId(stripBase(removeImportQuery(urlWithoutTimestamp), environment.config.base)); + for (const importedMod of mod.importedModules) { + if (importedMod.url !== hmrUrl) continue; + if (importedMod.lastHMRTimestamp > 0) { + const replacedUrl = injectQuery(urlWithoutTimestamp, `t=${importedMod.lastHMRTimestamp}`); + const start = hasQuotes ? imp.s + 1 : imp.s; + const end = hasQuotes ? imp.e - 1 : imp.e; + s.overwrite(start, end, replacedUrl); + } + if (imp.d === -1 && environment.config.dev.preTransformRequests) environment.warmupRequest(hmrUrl); + break; + } + } + const code = s.toString(); + result = { + ...transformResult, + code, + etag: (0, import_etag.default)(code, { weak: true }) + }; + } + if (timestamp > mod.lastInvalidationTimestamp) environment.moduleGraph.updateModuleTransformResult(mod, result); + return result; +} +const defaultModuleTypes = { + js: "js", + mjs: "js", + cjs: "js", + jsx: "jsx", + ts: "ts", + mts: "ts", + cts: "ts", + tsx: "tsx", + json: "json", + txt: "text", + css: "css" +}; +function getModuleTypeFromId(id) { + let pos = -1; + while ((pos = id.indexOf(".", pos + 1)) >= 0) { + const ext = id.slice(pos + 1); + const moduleType = defaultModuleTypes[ext]; + if (moduleType) return moduleType; + } +} +//#endregion +//#region ../../node_modules/.pnpm/strip-literal@3.1.0/node_modules/strip-literal/dist/index.mjs +var import_js_tokens = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => { + var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace; + Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y; + Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/uy; + StringLiteral = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y; + NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y; + Template = /[`}](?:[^`\\$]+|\\[^]|\$(?!\{))*(`|\$\{)?/y; + WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/uy; + LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y; + MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y; + SingleLineComment = /\/\/.*/y; + HashbangComment = /^#!.*/; + JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y; + JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/uy; + JSXString = /(['"])(?:[^'"]+|(?!\1)['"])*(\1)?/y; + JSXText = /[^<>{}]+/y; + TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/; + TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/; + KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/; + KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/; + Newline = RegExp(LineTerminatorSequence.source); + module.exports = function* (input, { jsx = false } = {}) { + var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack; + ({length} = input); + lastIndex = 0; + lastSignificantToken = ""; + stack = [{ tag: "JS" }]; + braces = []; + parenNesting = 0; + postfixIncDec = false; + if (match = HashbangComment.exec(input)) { + yield { + type: "HashbangComment", + value: match[0] + }; + lastIndex = match[0].length; + } + while (lastIndex < length) { + mode = stack[stack.length - 1]; + switch (mode.tag) { + case "JS": + case "JSNonExpressionParen": + case "InterpolationInTemplate": + case "InterpolationInJSX": + if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) { + RegularExpressionLiteral.lastIndex = lastIndex; + if (match = RegularExpressionLiteral.exec(input)) { + lastIndex = RegularExpressionLiteral.lastIndex; + lastSignificantToken = match[0]; + postfixIncDec = true; + yield { + type: "RegularExpressionLiteral", + value: match[0], + closed: match[1] !== void 0 && match[1] !== "\\" + }; + continue; + } + } + Punctuator.lastIndex = lastIndex; + if (match = Punctuator.exec(input)) { + punctuator = match[0]; + nextLastIndex = Punctuator.lastIndex; + nextLastSignificantToken = punctuator; + switch (punctuator) { + case "(": + if (lastSignificantToken === "?NonExpressionParenKeyword") stack.push({ + tag: "JSNonExpressionParen", + nesting: parenNesting + }); + parenNesting++; + postfixIncDec = false; + break; + case ")": + parenNesting--; + postfixIncDec = true; + if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) { + stack.pop(); + nextLastSignificantToken = "?NonExpressionParenEnd"; + postfixIncDec = false; + } + break; + case "{": + Punctuator.lastIndex = 0; + isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken)); + braces.push(isExpression); + postfixIncDec = false; + break; + case "}": + switch (mode.tag) { + case "InterpolationInTemplate": + if (braces.length === mode.nesting) { + Template.lastIndex = lastIndex; + match = Template.exec(input); + lastIndex = Template.lastIndex; + lastSignificantToken = match[0]; + if (match[1] === "${") { + lastSignificantToken = "?InterpolationInTemplate"; + postfixIncDec = false; + yield { + type: "TemplateMiddle", + value: match[0] + }; + } else { + stack.pop(); + postfixIncDec = true; + yield { + type: "TemplateTail", + value: match[0], + closed: match[1] === "`" + }; + } + continue; + } + break; + case "InterpolationInJSX": if (braces.length === mode.nesting) { + stack.pop(); + lastIndex += 1; + lastSignificantToken = "}"; + yield { + type: "JSXPunctuator", + value: "}" + }; + continue; + } + } + postfixIncDec = braces.pop(); + nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}"; + break; + case "]": + postfixIncDec = true; + break; + case "++": + case "--": + nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec"; + break; + case "<": + if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) { + stack.push({ tag: "JSXTag" }); + lastIndex += 1; + lastSignificantToken = "<"; + yield { + type: "JSXPunctuator", + value: punctuator + }; + continue; + } + postfixIncDec = false; + break; + default: postfixIncDec = false; + } + lastIndex = nextLastIndex; + lastSignificantToken = nextLastSignificantToken; + yield { + type: "Punctuator", + value: punctuator + }; + continue; + } + Identifier.lastIndex = lastIndex; + if (match = Identifier.exec(input)) { + lastIndex = Identifier.lastIndex; + nextLastSignificantToken = match[0]; + switch (match[0]) { + case "for": + case "if": + case "while": + case "with": if (lastSignificantToken !== "." && lastSignificantToken !== "?.") nextLastSignificantToken = "?NonExpressionParenKeyword"; + } + lastSignificantToken = nextLastSignificantToken; + postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]); + yield { + type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName", + value: match[0] + }; + continue; + } + StringLiteral.lastIndex = lastIndex; + if (match = StringLiteral.exec(input)) { + lastIndex = StringLiteral.lastIndex; + lastSignificantToken = match[0]; + postfixIncDec = true; + yield { + type: "StringLiteral", + value: match[0], + closed: match[2] !== void 0 + }; + continue; + } + NumericLiteral.lastIndex = lastIndex; + if (match = NumericLiteral.exec(input)) { + lastIndex = NumericLiteral.lastIndex; + lastSignificantToken = match[0]; + postfixIncDec = true; + yield { + type: "NumericLiteral", + value: match[0] + }; + continue; + } + Template.lastIndex = lastIndex; + if (match = Template.exec(input)) { + lastIndex = Template.lastIndex; + lastSignificantToken = match[0]; + if (match[1] === "${") { + lastSignificantToken = "?InterpolationInTemplate"; + stack.push({ + tag: "InterpolationInTemplate", + nesting: braces.length + }); + postfixIncDec = false; + yield { + type: "TemplateHead", + value: match[0] + }; + } else { + postfixIncDec = true; + yield { + type: "NoSubstitutionTemplate", + value: match[0], + closed: match[1] === "`" + }; + } + continue; + } + break; + case "JSXTag": + case "JSXTagEnd": + JSXPunctuator.lastIndex = lastIndex; + if (match = JSXPunctuator.exec(input)) { + lastIndex = JSXPunctuator.lastIndex; + nextLastSignificantToken = match[0]; + switch (match[0]) { + case "<": + stack.push({ tag: "JSXTag" }); + break; + case ">": + stack.pop(); + if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") { + nextLastSignificantToken = "?JSX"; + postfixIncDec = true; + } else stack.push({ tag: "JSXChildren" }); + break; + case "{": + stack.push({ + tag: "InterpolationInJSX", + nesting: braces.length + }); + nextLastSignificantToken = "?InterpolationInJSX"; + postfixIncDec = false; + break; + case "/": if (lastSignificantToken === "<") { + stack.pop(); + if (stack[stack.length - 1].tag === "JSXChildren") stack.pop(); + stack.push({ tag: "JSXTagEnd" }); + } + } + lastSignificantToken = nextLastSignificantToken; + yield { + type: "JSXPunctuator", + value: match[0] + }; + continue; + } + JSXIdentifier.lastIndex = lastIndex; + if (match = JSXIdentifier.exec(input)) { + lastIndex = JSXIdentifier.lastIndex; + lastSignificantToken = match[0]; + yield { + type: "JSXIdentifier", + value: match[0] + }; + continue; + } + JSXString.lastIndex = lastIndex; + if (match = JSXString.exec(input)) { + lastIndex = JSXString.lastIndex; + lastSignificantToken = match[0]; + yield { + type: "JSXString", + value: match[0], + closed: match[2] !== void 0 + }; + continue; + } + break; + case "JSXChildren": + JSXText.lastIndex = lastIndex; + if (match = JSXText.exec(input)) { + lastIndex = JSXText.lastIndex; + lastSignificantToken = match[0]; + yield { + type: "JSXText", + value: match[0] + }; + continue; + } + switch (input[lastIndex]) { + case "<": + stack.push({ tag: "JSXTag" }); + lastIndex++; + lastSignificantToken = "<"; + yield { + type: "JSXPunctuator", + value: "<" + }; + continue; + case "{": + stack.push({ + tag: "InterpolationInJSX", + nesting: braces.length + }); + lastIndex++; + lastSignificantToken = "?InterpolationInJSX"; + postfixIncDec = false; + yield { + type: "JSXPunctuator", + value: "{" + }; + continue; + } + } + WhiteSpace.lastIndex = lastIndex; + if (match = WhiteSpace.exec(input)) { + lastIndex = WhiteSpace.lastIndex; + yield { + type: "WhiteSpace", + value: match[0] + }; + continue; + } + LineTerminatorSequence.lastIndex = lastIndex; + if (match = LineTerminatorSequence.exec(input)) { + lastIndex = LineTerminatorSequence.lastIndex; + postfixIncDec = false; + if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere"; + yield { + type: "LineTerminatorSequence", + value: match[0] + }; + continue; + } + MultiLineComment.lastIndex = lastIndex; + if (match = MultiLineComment.exec(input)) { + lastIndex = MultiLineComment.lastIndex; + if (Newline.test(match[0])) { + postfixIncDec = false; + if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere"; + } + yield { + type: "MultiLineComment", + value: match[0], + closed: match[1] !== void 0 + }; + continue; + } + SingleLineComment.lastIndex = lastIndex; + if (match = SingleLineComment.exec(input)) { + lastIndex = SingleLineComment.lastIndex; + postfixIncDec = false; + yield { + type: "SingleLineComment", + value: match[0] + }; + continue; + } + firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex)); + lastIndex += firstCodePoint.length; + lastSignificantToken = firstCodePoint; + postfixIncDec = false; + yield { + type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid", + value: firstCodePoint + }; + } + }; +})))(), 1); +const FILL_COMMENT = " "; +function stripLiteralFromToken(token, fillChar, filter) { + if (token.type === "SingleLineComment") return FILL_COMMENT.repeat(token.value.length); + if (token.type === "MultiLineComment") return token.value.replace(/[^\n]/g, FILL_COMMENT); + if (token.type === "StringLiteral") { + if (!token.closed) return token.value; + const body = token.value.slice(1, -1); + if (filter(body)) return token.value[0] + fillChar.repeat(body.length) + token.value[token.value.length - 1]; + } + if (token.type === "NoSubstitutionTemplate") { + const body = token.value.slice(1, -1); + if (filter(body)) return `\`${body.replace(/[^\n]/g, fillChar)}\``; + } + if (token.type === "RegularExpressionLiteral") { + const body = token.value; + if (filter(body)) return body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${fillChar.repeat($1.length)}/${$2}`); + } + if (token.type === "TemplateHead") { + const body = token.value.slice(1, -2); + if (filter(body)) return `\`${body.replace(/[^\n]/g, fillChar)}\${`; + } + if (token.type === "TemplateTail") { + const body = token.value.slice(0, -2); + if (filter(body)) return `}${body.replace(/[^\n]/g, fillChar)}\``; + } + if (token.type === "TemplateMiddle") { + const body = token.value.slice(1, -2); + if (filter(body)) return `}${body.replace(/[^\n]/g, fillChar)}\${`; + } + return token.value; +} +function optionsWithDefaults(options) { + return { + fillChar: options?.fillChar ?? " ", + filter: options?.filter ?? (() => true) + }; +} +function stripLiteral(code, options) { + let result = ""; + const _options = optionsWithDefaults(options); + for (const token of (0, import_js_tokens.default)(code, { jsx: false })) result += stripLiteralFromToken(token, _options.fillChar, _options.filter); + return result; +} +//#endregion +//#region src/node/environment.ts +/** +* Creates a function that hides the complexities of a WeakMap with an initial value +* to implement object metadata. Used by plugins to implement cross hooks per +* environment metadata +* +* @experimental +*/ +function perEnvironmentState(initial) { + const stateMap = /* @__PURE__ */ new WeakMap(); + return function(context) { + const { environment } = context; + if (!stateMap.has(environment)) stateMap.set(environment, initial(environment)); + return stateMap.get(environment); + }; +} +//#endregion +//#region src/node/assetSource.ts +const ALLOWED_META_NAME = [ + "msapplication-tileimage", + "msapplication-square70x70logo", + "msapplication-square150x150logo", + "msapplication-wide310x150logo", + "msapplication-square310x310logo", + "msapplication-config", + "twitter:image" +]; +const ALLOWED_META_PROPERTY = [ + "og:image", + "og:image:url", + "og:image:secure_url", + "og:audio", + "og:audio:secure_url", + "og:video", + "og:video:secure_url" +]; +const DEFAULT_HTML_ASSET_SOURCES = { + audio: { srcAttributes: ["src"] }, + embed: { srcAttributes: ["src"] }, + img: { + srcAttributes: ["src"], + srcsetAttributes: ["srcset"] + }, + image: { srcAttributes: ["href", "xlink:href"] }, + input: { srcAttributes: ["src"] }, + link: { + srcAttributes: ["href"], + srcsetAttributes: ["imagesrcset"] + }, + object: { srcAttributes: ["data"] }, + source: { + srcAttributes: ["src"], + srcsetAttributes: ["srcset"] + }, + track: { srcAttributes: ["src"] }, + use: { srcAttributes: ["href", "xlink:href"] }, + video: { srcAttributes: ["src", "poster"] }, + meta: { + srcAttributes: ["content"], + filter({ attributes }) { + if (attributes.name && ALLOWED_META_NAME.includes(attributes.name.trim().toLowerCase())) return true; + if (attributes.property && ALLOWED_META_PROPERTY.includes(attributes.property.trim().toLowerCase())) return true; + return false; + } + } +}; +/** +* Given a HTML node, find all attributes that references an asset to be processed +*/ +function getNodeAssetAttributes(node, additionalAssetSources) { + const defaults = DEFAULT_HTML_ASSET_SOURCES[node.nodeName]; + const additional = additionalAssetSources?.[node.nodeName]; + if (!defaults && !additional) return []; + const attributes = {}; + for (const attr of node.attrs) attributes[getAttrKey(attr)] = attr.value; + if ("vite-ignore" in attributes) return [{ + type: "remove", + key: "vite-ignore", + value: "", + attributes, + location: node.sourceCodeLocation.attrs["vite-ignore"] + }]; + const actions = []; + function handleAttributeKey(key, type, filter) { + const value = attributes[key]; + if (!value) return; + if (filter && !filter({ + key, + value, + attributes + })) return; + actions.push({ + type, + key, + value, + attributes, + location: node.sourceCodeLocation.attrs[key] + }); + } + if (defaults) { + defaults.srcAttributes?.forEach((key) => handleAttributeKey(key, "src", defaults.filter)); + defaults.srcsetAttributes?.forEach((key) => handleAttributeKey(key, "srcset", defaults.filter)); + } + if (additional) { + additional.srcAttributes?.forEach((key) => handleAttributeKey(key, "src", additional.filter)); + additional.srcsetAttributes?.forEach((key) => handleAttributeKey(key, "srcset", additional.filter)); + } + return actions; +} +function getAttrKey(attr) { + return attr.prefix === void 0 ? attr.name : `${attr.prefix}:${attr.name}`; +} +//#endregion +//#region src/node/plugins/asset.ts +const assetUrlRE = /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g; +const jsSourceMapRE = /\.[cm]?js\.map$/; +const noInlineRE = /[?&]no-inline\b/; +const inlineRE$3 = /[?&]inline\b/; +const assetCache = /* @__PURE__ */ new WeakMap(); +/** a set of referenceId for entry CSS assets for each environment */ +const cssEntriesMap = /* @__PURE__ */ new WeakMap(); +function registerCustomMime() { + mimes.ico = "image/x-icon"; + mimes.cur = "image/x-icon"; + mimes.flac = "audio/flac"; + mimes.eot = "application/vnd.ms-fontobject"; +} +function renderAssetUrlInJS(pluginContext, chunk, opts, code) { + const { environment } = pluginContext; + const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(opts.format, environment.config.isWorker); + let match; + let s; + assetUrlRE.lastIndex = 0; + while (match = assetUrlRE.exec(code)) { + s ||= new MagicString(code); + const [full, referenceId, postfix = ""] = match; + const file = pluginContext.getFileName(referenceId); + chunk.viteMetadata.importedAssets.add(cleanUrl(file)); + const replacement = toOutputFilePathInJS(environment, file + postfix, "asset", chunk.fileName, "js", toRelativeRuntime); + const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`; + s.update(match.index, match.index + full.length, replacementString); + } + const publicAssetUrlMap = publicAssetUrlCache.get(environment.getTopLevelConfig()); + publicAssetUrlRE.lastIndex = 0; + while (match = publicAssetUrlRE.exec(code)) { + s ||= new MagicString(code); + const [full, hash] = match; + const replacement = toOutputFilePathInJS(environment, publicAssetUrlMap.get(hash).slice(1), "public", chunk.fileName, "js", toRelativeRuntime); + const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`; + s.update(match.index, match.index + full.length, replacementString); + } + return s; +} +/** +* Also supports loading plain strings with import text from './foo.txt?raw' +*/ +function assetPlugin(config) { + registerCustomMime(); + return { + name: "vite:asset", + perEnvironmentStartEndDuringDev: true, + buildStart() { + assetCache.set(this.environment, /* @__PURE__ */ new Map()); + cssEntriesMap.set(this.environment, /* @__PURE__ */ new Map()); + }, + resolveId: { + filter: { id: [ + urlRE$1, + DEFAULT_ASSETS_RE, + ...makeIdFiltersToMatchWithQuery(config.rawAssetsInclude).map((v) => typeof v === "string" ? pm.makeRe(v, { dot: true }) : v) + ] }, + handler(id) { + if (!config.assetsInclude(cleanUrl(id)) && !urlRE$1.test(id)) return; + if (checkPublicFile(id, config)) return id; + } + }, + load: { + filter: { id: { + include: [ + rawRE$1, + urlRE$1, + DEFAULT_ASSETS_RE, + ...makeIdFiltersToMatchWithQuery(config.rawAssetsInclude) + ], + exclude: /^\0/ + } }, + async handler(id) { + if (rawRE$1.test(id)) { + const file = checkPublicFile(id, config) || cleanUrl(id); + this.addWatchFile(file); + return { + code: `export default ${JSON.stringify(await fsp.readFile(file, "utf-8"))}`, + map: { mappings: "" }, + moduleType: "js" + }; + } + if (!urlRE$1.test(id) && !config.assetsInclude(cleanUrl(id))) return; + id = removeUrlQuery(id); + let url = await fileToUrl$1(this, id); + if (!url.startsWith("data:") && this.environment.mode === "dev") { + const mod = this.environment.moduleGraph.getModuleById(id); + if (mod && mod.lastHMRTimestamp > 0) url = injectQuery(url, `t=${mod.lastHMRTimestamp}`); + } + return { + code: `export default ${JSON.stringify(encodeURIPath(url))}`, + moduleSideEffects: config.command === "build" && this.getModuleInfo(id)?.isEntry ? "no-treeshake" : false, + meta: config.command === "build" ? { "vite:asset": true } : void 0, + moduleType: "js" + }; + } + }, + ...config.command === "build" ? { renderChunk(code, chunk, opts) { + const s = renderAssetUrlInJS(this, chunk, opts, code); + if (s) return { + code: s.toString(), + map: this.environment.config.build.sourcemap ? s.generateMap({ hires: "boundary" }) : null + }; + else return null; + } } : {}, + generateBundle(_, bundle) { + let importedFiles; + for (const file in bundle) { + const chunk = bundle[file]; + if (chunk.type === "chunk" && chunk.isEntry && chunk.moduleIds.length === 1 && config.assetsInclude(chunk.moduleIds[0]) && this.getModuleInfo(chunk.moduleIds[0])?.meta["vite:asset"]) { + if (!importedFiles) { + importedFiles = /* @__PURE__ */ new Set(); + for (const file in bundle) { + const chunk = bundle[file]; + if (chunk.type === "chunk") { + for (const importedFile of chunk.imports) importedFiles.add(importedFile); + for (const importedFile of chunk.dynamicImports) importedFiles.add(importedFile); + } + } + } + if (!importedFiles.has(file)) delete bundle[file]; + } + } + if (config.command === "build" && !this.environment.config.build.emitAssets) { + for (const file in bundle) if (bundle[file].type === "asset" && !file.endsWith("ssr-manifest.json") && !jsSourceMapRE.test(file)) delete bundle[file]; + } + }, + watchChange(id) { + assetCache.get(this.environment)?.delete(normalizePath(id)); + } + }; +} +async function fileToUrl$1(pluginContext, id, asFileUrl = false) { + const { environment } = pluginContext; + if (!environment.config.isBundled) return fileToDevUrl(environment, id, asFileUrl); + else return fileToBuiltUrl(pluginContext, id); +} +async function fileToDevUrl(environment, id, asFileUrl = false) { + const config = environment.getTopLevelConfig(); + const publicFile = checkPublicFile(id, config); + if (inlineRE$3.test(id)) { + const file = publicFile || cleanUrl(id); + return assetToDataURL(environment, file, await fsp.readFile(file)); + } + const cleanedId = cleanUrl(id); + if (cleanedId.endsWith(".svg")) { + const file = publicFile || cleanedId; + const content = await fsp.readFile(file); + if (shouldInline(environment, file, id, content, void 0, void 0)) return assetToDataURL(environment, file, content); + } + if (asFileUrl) return pathToFileURL(cleanedId).href; + let rtn; + if (publicFile) rtn = id; + else if (id.startsWith(withTrailingSlash(config.root))) rtn = "/" + path.posix.relative(config.root, id); + else rtn = path.posix.join(FS_PREFIX, id); + return joinUrlSegments(joinUrlSegments(config.server.origin ?? "", config.decodedBase), removeLeadingSlash(rtn)); +} +function getPublicAssetFilename(hash, config) { + return publicAssetUrlCache.get(config)?.get(hash); +} +const publicAssetUrlCache = /* @__PURE__ */ new WeakMap(); +const publicAssetUrlRE = /__VITE_PUBLIC_ASSET__([a-z\d]{8})__/g; +function publicFileToBuiltUrl(url, config) { + if (config.command !== "build") return joinUrlSegments(config.decodedBase, url); + const hash = getHash(url); + let cache = publicAssetUrlCache.get(config); + if (!cache) { + cache = /* @__PURE__ */ new Map(); + publicAssetUrlCache.set(config, cache); + } + if (!cache.get(hash)) cache.set(hash, url); + return `__VITE_PUBLIC_ASSET__${hash}__`; +} +const GIT_LFS_PREFIX = Buffer$1.from("version https://git-lfs.github.com"); +function isGitLfsPlaceholder(content) { + if (content.length < GIT_LFS_PREFIX.length) return false; + return GIT_LFS_PREFIX.compare(content, 0, GIT_LFS_PREFIX.length) === 0; +} +/** +* Register an asset to be emitted as part of the bundle (if necessary) +* and returns the resolved public URL +*/ +async function fileToBuiltUrl(pluginContext, id, skipPublicCheck = false, forceInline) { + const environment = pluginContext.environment; + const topLevelConfig = environment.getTopLevelConfig(); + if (!skipPublicCheck) { + const publicFile = checkPublicFile(id, topLevelConfig); + if (publicFile) if (inlineRE$3.test(id)) id = publicFile; + else return publicFileToBuiltUrl(id, topLevelConfig); + } + const cache = assetCache.get(environment); + const cached = cache.get(id); + if (cached) return cached; + let { file, postfix } = splitFileAndPostfix(id); + const content = await fsp.readFile(file); + let url; + if (shouldInline(environment, file, id, content, pluginContext, forceInline)) url = assetToDataURL(environment, file, content); + else { + const originalFileName = normalizePath(path.relative(environment.config.root, file)); + const referenceId = pluginContext.emitFile({ + type: "asset", + name: path.basename(file), + originalFileName, + source: content + }); + if (environment.config.command === "build" && noInlineRE.test(postfix)) postfix = postfix.replace(noInlineRE, "").replace(/^&/, "?"); + if (environment.config.command === "serve" && environment.config.isBundled) url = toOutputFilePathInJSForBundledDev(environment, pluginContext.getFileName(referenceId)); + else url = `__VITE_ASSET__${referenceId}__${postfix ? `$_${postfix}__` : ``}`; + } + cache.set(id, url); + return url; +} +function toOutputFilePathInJSForBundledDev(environment, filename) { + const outputUrl = toOutputFilePathInJS(environment, filename, "asset", "assets/dummy.js", "js", () => { + throw new Error("unreachable"); + }); + if (typeof outputUrl === "object") throw new Error("unreachable"); + return outputUrl; +} +async function urlToBuiltUrl(pluginContext, url, importer, forceInline) { + const topLevelConfig = pluginContext.environment.getTopLevelConfig(); + if (checkPublicFile(url, topLevelConfig)) return publicFileToBuiltUrl(url, topLevelConfig); + return fileToBuiltUrl(pluginContext, normalizePath(url[0] === "/" ? path.join(topLevelConfig.root, url) : path.join(path.dirname(importer), url)), true, forceInline); +} +function shouldInline(environment, file, id, content, buildPluginContext, forceInline) { + if (noInlineRE.test(id)) return false; + if (inlineRE$3.test(id)) return true; + if (buildPluginContext) { + if (environment.config.build.lib) return true; + if (buildPluginContext.getModuleInfo(id)?.isEntry) return false; + } + if (forceInline !== void 0) return forceInline; + if (file.endsWith(".html")) return false; + if (file.endsWith(".svg") && id.includes("#")) return false; + let limit; + const { assetsInlineLimit } = environment.config.build; + if (typeof assetsInlineLimit === "function") { + const userShouldInline = assetsInlineLimit(file, content); + if (userShouldInline != null) return userShouldInline; + limit = DEFAULT_ASSETS_INLINE_LIMIT; + } else limit = Number(assetsInlineLimit); + return content.length < limit && !isGitLfsPlaceholder(content); +} +function assetToDataURL(environment, file, content) { + if (environment.config.build.lib && isGitLfsPlaceholder(content)) environment.logger.warn(import_picocolors.default.yellow(`Inlined file ${file} was not downloaded via Git LFS`)); + if (file.endsWith(".svg")) return svgToDataURL(content); + else return `data:${lookup(file) ?? "application/octet-stream"};base64,${content.toString("base64")}`; +} +const nestedQuotesRE = /"[^"']*'[^"]*"|'[^'"]*"[^']*'/; +function svgToDataURL(content) { + const stringContent = content.toString(); + if (stringContent.includes("\s+<").replaceAll("\"", "'").replaceAll("%", "%25").replaceAll("#", "%23").replaceAll("<", "%3c").replaceAll(">", "%3e").replaceAll(/\s+/g, "%20"); +} +//#endregion +//#region ../../node_modules/.pnpm/lilconfig@3.1.3/node_modules/lilconfig/src/index.js +var require_src$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const path$2 = __require("path"); + const fs$1 = __require("fs"); + const os$1 = __require("os"); + const url = __require("url"); + const fsReadFileAsync = fs$1.promises.readFile; + /** @type {(name: string, sync: boolean) => string[]} */ + function getDefaultSearchPlaces(name, sync) { + return [ + "package.json", + `.${name}rc.json`, + `.${name}rc.js`, + `.${name}rc.cjs`, + ...sync ? [] : [`.${name}rc.mjs`], + `.config/${name}rc`, + `.config/${name}rc.json`, + `.config/${name}rc.js`, + `.config/${name}rc.cjs`, + ...sync ? [] : [`.config/${name}rc.mjs`], + `${name}.config.js`, + `${name}.config.cjs`, + ...sync ? [] : [`${name}.config.mjs`] + ]; + } + /** + * @type {(p: string) => string} + * + * see #17 + * On *nix, if cwd is not under homedir, + * the last path will be '', ('/build' -> '') + * but it should be '/' actually. + * And on Windows, this will never happen. ('C:\build' -> 'C:') + */ + function parentDir(p) { + return path$2.dirname(p) || path$2.sep; + } + /** @type {import('./index').LoaderSync} */ + const jsonLoader = (_, content) => JSON.parse(content); + const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require; + /** @type {import('./index').LoadersSync} */ + const defaultLoadersSync = Object.freeze({ + ".js": requireFunc, + ".json": requireFunc, + ".cjs": requireFunc, + noExt: jsonLoader + }); + module.exports.defaultLoadersSync = defaultLoadersSync; + /** @type {import('./index').Loader} */ + const dynamicImport = async (id) => { + try { + return (await import( + /* webpackIgnore: true */ + url.pathToFileURL(id).href +)).default; + } catch (e) { + try { + return requireFunc(id); + } catch (requireE) { + if (requireE.code === "ERR_REQUIRE_ESM" || requireE instanceof SyntaxError && requireE.toString().includes("Cannot use import statement outside a module")) throw e; + throw requireE; + } + } + }; + /** @type {import('./index').Loaders} */ + const defaultLoaders = Object.freeze({ + ".js": dynamicImport, + ".mjs": dynamicImport, + ".cjs": dynamicImport, + ".json": jsonLoader, + noExt: jsonLoader + }); + module.exports.defaultLoaders = defaultLoaders; + /** + * @param {string} name + * @param {import('./index').Options | import('./index').OptionsSync} options + * @param {boolean} sync + * @returns {Required} + */ + function getOptions(name, options, sync) { + /** @type {Required} */ + const conf = { + stopDir: os$1.homedir(), + searchPlaces: getDefaultSearchPlaces(name, sync), + ignoreEmptySearchPlaces: true, + cache: true, + transform: (x) => x, + packageProp: [name], + ...options, + loaders: { + ...sync ? defaultLoadersSync : defaultLoaders, + ...options.loaders + } + }; + conf.searchPlaces.forEach((place) => { + const key = path$2.extname(place) || "noExt"; + const loader = conf.loaders[key]; + if (!loader) throw new Error(`Missing loader for extension "${place}"`); + if (typeof loader !== "function") throw new Error(`Loader for extension "${place}" is not a function: Received ${typeof loader}.`); + }); + return conf; + } + /** @type {(props: string | string[], obj: Record) => unknown} */ + function getPackageProp(props, obj) { + if (typeof props === "string" && props in obj) return obj[props]; + return (Array.isArray(props) ? props : props.split(".")).reduce((acc, prop) => acc === void 0 ? acc : acc[prop], obj) || null; + } + /** @param {string} filepath */ + function validateFilePath(filepath) { + if (!filepath) throw new Error("load must pass a non-empty string"); + } + /** @type {(loader: import('./index').Loader, ext: string) => void} */ + function validateLoader(loader, ext) { + if (!loader) throw new Error(`No loader specified for extension "${ext}"`); + if (typeof loader !== "function") throw new Error("loader is not a function"); + } + /** @type {(enableCache: boolean) => (c: Map, filepath: string, res: T) => T} */ + const makeEmplace = (enableCache) => (c, filepath, res) => { + if (enableCache) c.set(filepath, res); + return res; + }; + /** @type {import('./index').lilconfig} */ + module.exports.lilconfig = function lilconfig(name, options) { + const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache } = getOptions(name, options ?? {}, false); + const searchCache = /* @__PURE__ */ new Map(); + const loadCache = /* @__PURE__ */ new Map(); + const emplace = makeEmplace(cache); + return { + async search(searchFrom = process.cwd()) { + /** @type {import('./index').LilconfigResult} */ + const result = { + config: null, + filepath: "" + }; + /** @type {Set} */ + const visited = /* @__PURE__ */ new Set(); + let dir = searchFrom; + dirLoop: while (true) { + if (cache) { + const r = searchCache.get(dir); + if (r !== void 0) { + for (const p of visited) searchCache.set(p, r); + return r; + } + visited.add(dir); + } + for (const searchPlace of searchPlaces) { + const filepath = path$2.join(dir, searchPlace); + try { + await fs$1.promises.access(filepath); + } catch { + continue; + } + const content = String(await fsReadFileAsync(filepath)); + const loaderKey = path$2.extname(searchPlace) || "noExt"; + const loader = loaders[loaderKey]; + if (searchPlace === "package.json") { + const pkg = await loader(filepath, content); + const maybeConfig = getPackageProp(packageProp, pkg); + if (maybeConfig != null) { + result.config = maybeConfig; + result.filepath = filepath; + break dirLoop; + } + continue; + } + const isEmpty = content.trim() === ""; + if (isEmpty && ignoreEmptySearchPlaces) continue; + if (isEmpty) { + result.isEmpty = true; + result.config = void 0; + } else { + validateLoader(loader, loaderKey); + result.config = await loader(filepath, content); + } + result.filepath = filepath; + break dirLoop; + } + if (dir === stopDir || dir === parentDir(dir)) break dirLoop; + dir = parentDir(dir); + } + const transformed = result.filepath === "" && result.config === null ? transform(null) : transform(result); + if (cache) for (const p of visited) searchCache.set(p, transformed); + return transformed; + }, + async load(filepath) { + validateFilePath(filepath); + const absPath = path$2.resolve(process.cwd(), filepath); + if (cache && loadCache.has(absPath)) return loadCache.get(absPath); + const { base, ext } = path$2.parse(absPath); + const loaderKey = ext || "noExt"; + const loader = loaders[loaderKey]; + validateLoader(loader, loaderKey); + const content = String(await fsReadFileAsync(absPath)); + if (base === "package.json") { + const pkg = await loader(absPath, content); + return emplace(loadCache, absPath, transform({ + config: getPackageProp(packageProp, pkg), + filepath: absPath + })); + } + /** @type {import('./index').LilconfigResult} */ + const result = { + config: null, + filepath: absPath + }; + const isEmpty = content.trim() === ""; + if (isEmpty && ignoreEmptySearchPlaces) return emplace(loadCache, absPath, transform({ + config: void 0, + filepath: absPath, + isEmpty: true + })); + result.config = isEmpty ? void 0 : await loader(absPath, content); + return emplace(loadCache, absPath, transform(isEmpty ? { + ...result, + isEmpty, + config: void 0 + } : result)); + }, + clearLoadCache() { + if (cache) loadCache.clear(); + }, + clearSearchCache() { + if (cache) searchCache.clear(); + }, + clearCaches() { + if (cache) { + loadCache.clear(); + searchCache.clear(); + } + } + }; + }; + /** @type {import('./index').lilconfigSync} */ + module.exports.lilconfigSync = function lilconfigSync(name, options) { + const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache } = getOptions(name, options ?? {}, true); + const searchCache = /* @__PURE__ */ new Map(); + const loadCache = /* @__PURE__ */ new Map(); + const emplace = makeEmplace(cache); + return { + search(searchFrom = process.cwd()) { + /** @type {import('./index').LilconfigResult} */ + const result = { + config: null, + filepath: "" + }; + /** @type {Set} */ + const visited = /* @__PURE__ */ new Set(); + let dir = searchFrom; + dirLoop: while (true) { + if (cache) { + const r = searchCache.get(dir); + if (r !== void 0) { + for (const p of visited) searchCache.set(p, r); + return r; + } + visited.add(dir); + } + for (const searchPlace of searchPlaces) { + const filepath = path$2.join(dir, searchPlace); + try { + fs$1.accessSync(filepath); + } catch { + continue; + } + const loaderKey = path$2.extname(searchPlace) || "noExt"; + const loader = loaders[loaderKey]; + const content = String(fs$1.readFileSync(filepath)); + if (searchPlace === "package.json") { + const pkg = loader(filepath, content); + const maybeConfig = getPackageProp(packageProp, pkg); + if (maybeConfig != null) { + result.config = maybeConfig; + result.filepath = filepath; + break dirLoop; + } + continue; + } + const isEmpty = content.trim() === ""; + if (isEmpty && ignoreEmptySearchPlaces) continue; + if (isEmpty) { + result.isEmpty = true; + result.config = void 0; + } else { + validateLoader(loader, loaderKey); + result.config = loader(filepath, content); + } + result.filepath = filepath; + break dirLoop; + } + if (dir === stopDir || dir === parentDir(dir)) break dirLoop; + dir = parentDir(dir); + } + const transformed = result.filepath === "" && result.config === null ? transform(null) : transform(result); + if (cache) for (const p of visited) searchCache.set(p, transformed); + return transformed; + }, + load(filepath) { + validateFilePath(filepath); + const absPath = path$2.resolve(process.cwd(), filepath); + if (cache && loadCache.has(absPath)) return loadCache.get(absPath); + const { base, ext } = path$2.parse(absPath); + const loaderKey = ext || "noExt"; + const loader = loaders[loaderKey]; + validateLoader(loader, loaderKey); + const content = String(fs$1.readFileSync(absPath)); + if (base === "package.json") { + const pkg = loader(absPath, content); + return transform({ + config: getPackageProp(packageProp, pkg), + filepath: absPath + }); + } + const result = { + config: null, + filepath: absPath + }; + const isEmpty = content.trim() === ""; + if (isEmpty && ignoreEmptySearchPlaces) return emplace(loadCache, absPath, transform({ + filepath: absPath, + config: void 0, + isEmpty: true + })); + result.config = isEmpty ? void 0 : loader(absPath, content); + return emplace(loadCache, absPath, transform(isEmpty ? { + ...result, + isEmpty, + config: void 0 + } : result)); + }, + clearLoadCache() { + if (cache) loadCache.clear(); + }, + clearSearchCache() { + if (cache) searchCache.clear(); + }, + clearCaches() { + if (cache) { + loadCache.clear(); + searchCache.clear(); + } + } + }; + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16_tsx@4.23.0_yaml@2.9.0/node_modules/postcss-load-config/src/req.js +var require_req = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { createRequire: createRequire$1 } = __require("node:module"); + const { fileURLToPath: fileURLToPath$1, pathToFileURL: pathToFileURL$1 } = __require("node:url"); + const TS_EXT_RE = /\.[mc]?ts$/; + let tsx; + let jiti; + let importError = []; + /** + * @param {string} name + * @param {string} rootFile + * @returns {Promise} + */ + async function req(name, rootFile = fileURLToPath$1(import.meta.url)) { + let url = createRequire$1(rootFile).resolve(name); + try { + return (await import(`${pathToFileURL$1(url)}?t=${Date.now()}`)).default; + } catch (err) { + if (!TS_EXT_RE.test(url)) + /* c8 ignore start */ + throw err; + } + if (tsx === void 0) try { + tsx = await import("tsx/cjs/api"); + } catch (error) { + importError.push(error); + } + if (tsx) { + let loaded = tsx.require(name, rootFile); + return loaded && "__esModule" in loaded ? loaded.default : loaded; + } + if (jiti === void 0) try { + jiti = (await import("jiti")).default; + } catch (error) { + importError.push(error); + } + if (jiti) return jiti(rootFile, { interopDefault: true })(name); + throw new Error(`'tsx' or 'jiti' is required for the TypeScript configuration files. Make sure it is installed\nError: ${importError.map((error) => error.message).join("\n")}`); + } + module.exports = req; +})); +//#endregion +//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16_tsx@4.23.0_yaml@2.9.0/node_modules/postcss-load-config/src/options.js +var require_options = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const req = require_req(); + /** + * Load Options + * + * @private + * @method options + * + * @param {Object} config PostCSS Config + * + * @return {Promise} options PostCSS Options + */ + async function options(config, file) { + if (config.parser && typeof config.parser === "string") try { + config.parser = await req(config.parser, file); + } catch (err) { + throw new Error(`Loading PostCSS Parser failed: ${err.message}\n\n(@${file})`); + } + if (config.syntax && typeof config.syntax === "string") try { + config.syntax = await req(config.syntax, file); + } catch (err) { + throw new Error(`Loading PostCSS Syntax failed: ${err.message}\n\n(@${file})`); + } + if (config.stringifier && typeof config.stringifier === "string") try { + config.stringifier = await req(config.stringifier, file); + } catch (err) { + throw new Error(`Loading PostCSS Stringifier failed: ${err.message}\n\n(@${file})`); + } + return config; + } + module.exports = options; +})); +//#endregion +//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16_tsx@4.23.0_yaml@2.9.0/node_modules/postcss-load-config/src/plugins.js +var require_plugins = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const req = require_req(); + /** + * Plugin Loader + * + * @private + * @method load + * + * @param {String} plugin PostCSS Plugin Name + * @param {Object} options PostCSS Plugin Options + * + * @return {Promise} PostCSS Plugin + */ + async function load(plugin, options, file) { + try { + if (options === null || options === void 0 || Object.keys(options).length === 0) return await req(plugin, file); + else return (await req(plugin, file))(options); + } catch (err) { + throw new Error(`Loading PostCSS Plugin failed: ${err.message}\n\n(@${file})`); + } + } + /** + * Load Plugins + * + * @private + * @method plugins + * + * @param {Object} config PostCSS Config Plugins + * + * @return {Promise} plugins PostCSS Plugins + */ + async function plugins(config, file) { + let list = []; + if (Array.isArray(config.plugins)) list = config.plugins.filter(Boolean); + else { + list = Object.entries(config.plugins).filter(([, options]) => { + return options !== false; + }).map(([plugin, options]) => { + return load(plugin, options, file); + }); + list = await Promise.all(list); + } + if (list.length && list.length > 0) list.forEach((plugin, i) => { + if (plugin.default) plugin = plugin.default; + if (plugin.postcss === true) plugin = plugin(); + else if (plugin.postcss) plugin = plugin.postcss; + if (!(typeof plugin === "object" && Array.isArray(plugin.plugins) || typeof plugin === "object" && plugin.postcssPlugin || typeof plugin === "function")) throw new TypeError(`Invalid PostCSS Plugin found at: plugins[${i}]\n\n(@${file})`); + }); + return list; + } + module.exports = plugins; +})); +//#endregion +//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.16_tsx@4.23.0_yaml@2.9.0/node_modules/postcss-load-config/src/index.js +var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { resolve: resolve$3 } = __require("node:path"); + const config = require_src$1(); + const loadOptions = require_options(); + const loadPlugins = require_plugins(); + const req = require_req(); + const interopRequireDefault = (obj) => obj && obj.__esModule ? obj : { default: obj }; + /** + * Process the result from cosmiconfig + * + * @param {Object} ctx Config Context + * @param {Object} result Cosmiconfig result + * + * @return {Promise} PostCSS Config + */ + async function processResult(ctx, result) { + let file = result.filepath || ""; + let projectConfig = interopRequireDefault(result.config).default || {}; + if (typeof projectConfig === "function") projectConfig = projectConfig(ctx); + else projectConfig = Object.assign({}, projectConfig, ctx); + if (!projectConfig.plugins) projectConfig.plugins = []; + let res = { + file, + options: await loadOptions(projectConfig, file), + plugins: await loadPlugins(projectConfig, file) + }; + delete projectConfig.plugins; + return res; + } + /** + * Builds the Config Context + * + * @param {Object} ctx Config Context + * + * @return {Object} Config Context + */ + function createContext(ctx) { + /** + * @type {Object} + * + * @prop {String} cwd=process.cwd() Config search start location + * @prop {String} env=process.env.NODE_ENV Config Enviroment, will be set to `development` by `postcss-load-config` if `process.env.NODE_ENV` is `undefined` + */ + ctx = Object.assign({ + cwd: process.cwd(), + env: process.env.NODE_ENV + }, ctx); + if (!ctx.env) process.env.NODE_ENV = "development"; + return ctx; + } + async function loader(filepath) { + return req(filepath); + } + let yaml; + async function yamlLoader(_, content) { + if (!yaml) try { + yaml = await import("yaml"); + } catch (e) { + /* c8 ignore start */ + throw new Error(`'yaml' is required for the YAML configuration files. Make sure it is installed\nError: ${e.message}`); + } + return yaml.parse(content); + } + /** @return {import('lilconfig').Options} */ + const withLoaders = (options = {}) => { + let moduleName = "postcss"; + return { + ...options, + loaders: { + ...options.loaders, + ".cjs": loader, + ".cts": loader, + ".js": loader, + ".mjs": loader, + ".mts": loader, + ".ts": loader, + ".yaml": yamlLoader, + ".yml": yamlLoader + }, + searchPlaces: [ + ...options.searchPlaces || [], + "package.json", + `.${moduleName}rc`, + `.${moduleName}rc.json`, + `.${moduleName}rc.yaml`, + `.${moduleName}rc.yml`, + `.${moduleName}rc.ts`, + `.${moduleName}rc.cts`, + `.${moduleName}rc.mts`, + `.${moduleName}rc.js`, + `.${moduleName}rc.cjs`, + `.${moduleName}rc.mjs`, + `${moduleName}.config.ts`, + `${moduleName}.config.cts`, + `${moduleName}.config.mts`, + `${moduleName}.config.js`, + `${moduleName}.config.cjs`, + `${moduleName}.config.mjs` + ] + }; + }; + /** + * Load Config + * + * @method rc + * + * @param {Object} ctx Config Context + * @param {String} path Config Path + * @param {Object} options Config Options + * + * @return {Promise} config PostCSS Config + */ + function rc(ctx, path, options) { + /** + * @type {Object} The full Config Context + */ + ctx = createContext(ctx); + /** + * @type {String} `process.cwd()` + */ + path = path ? resolve$3(path) : process.cwd(); + return config.lilconfig("postcss", withLoaders(options)).search(path).then((result) => { + if (!result) throw new Error(`No PostCSS Config found in: ${path}`); + return processResult(ctx, result); + }); + } + /** + * Autoload Config for PostCSS + * + * @author Michael Ciniawsky @michael-ciniawsky + * @license MIT + * + * @module postcss-load-config + * @version 2.1.0 + * + * @requires comsiconfig + * @requires ./options + * @requires ./plugins + */ + module.exports = rc; +})); +//#endregion +//#region src/node/idResolver.ts +/** +* Some projects like Astro were overriding config.createResolver to add a custom +* alias plugin. For the client and ssr environments, we root through it to avoid +* breaking changes for now. +*/ +function createBackCompatIdResolver(config, options) { + const compatResolve = config.createResolver(options); + let resolve; + return async (environment, id, importer, aliasOnly) => { + if (environment.name === "client" || environment.name === "ssr") return compatResolve(id, importer, aliasOnly, environment.name === "ssr"); + resolve ??= createIdResolver(config, options); + return resolve(environment, id, importer, aliasOnly); + }; +} +/** +* Create an internal resolver to be used in special scenarios, e.g. +* optimizer and handling css @imports +*/ +function createIdResolver(config, options) { + const scan = options?.scan; + const pluginContainerMap = /* @__PURE__ */ new Map(); + async function resolve(environment, id, importer) { + let pluginContainer = pluginContainerMap.get(environment); + if (!pluginContainer) { + pluginContainer = await createEnvironmentPluginContainer(environment, [alias$1({ entries: environment.config.resolve.alias }), ...oxcResolvePlugin({ + root: config.root, + isProduction: config.isProduction, + isBuild: config.command === "build", + asSrc: true, + preferRelative: false, + tryIndex: true, + ...options, + idOnly: true + }, environment.config, true)], void 0, false); + pluginContainerMap.set(environment, pluginContainer); + } + return await pluginContainer.resolveId(id, importer, { scan }); + } + const aliasOnlyPluginContainerMap = /* @__PURE__ */ new Map(); + async function resolveAlias(environment, id, importer) { + let pluginContainer = aliasOnlyPluginContainerMap.get(environment); + if (!pluginContainer) { + pluginContainer = await createEnvironmentPluginContainer(environment, [alias$1({ entries: environment.config.resolve.alias })], void 0, false); + aliasOnlyPluginContainerMap.set(environment, pluginContainer); + } + return await pluginContainer.resolveId(id, importer, { scan }); + } + return async (environment, id, importer, aliasOnly) => { + return (await (aliasOnly ? resolveAlias : resolve)(environment, id, importer))?.id; + }; +} +//#endregion +//#region src/node/baseEnvironment.ts +const environmentColors = [ + import_picocolors.default.blue, + import_picocolors.default.magenta, + import_picocolors.default.green, + import_picocolors.default.gray +]; +var PartialEnvironment = class { + name; + getTopLevelConfig() { + return this._topLevelConfig; + } + config; + logger; + /** + * @internal + */ + _options; + /** + * @internal + */ + _topLevelConfig; + constructor(name, topLevelConfig, options = topLevelConfig.environments[name]) { + if (!/^[\w$]+$/.test(name)) throw new Error(`Invalid environment name "${name}". Environment names must only contain alphanumeric characters and "$", "_".`); + this.name = name; + this._topLevelConfig = topLevelConfig; + this._options = options; + this.config = new Proxy(options, { get: (target, prop) => { + if (prop === "logger") return this.logger; + if (prop in target) return this._options[prop]; + return this._topLevelConfig[prop]; + } }); + const environment = import_picocolors.default.dim(`(${this.name})`); + const colorIndex = [...this.name].reduce((acc, c) => acc + c.charCodeAt(0), 0) % environmentColors.length; + const infoColor = environmentColors[colorIndex || 0]; + this.logger = { + get hasWarned() { + return topLevelConfig.logger.hasWarned; + }, + info(msg, opts) { + return topLevelConfig.logger.info(msg, { + ...opts, + environment: infoColor(environment) + }); + }, + warn(msg, opts) { + return topLevelConfig.logger.warn(msg, { + ...opts, + environment: import_picocolors.default.yellow(environment) + }); + }, + warnOnce(msg, opts) { + return topLevelConfig.logger.warnOnce(msg, { + ...opts, + environment: import_picocolors.default.yellow(environment) + }); + }, + error(msg, opts) { + return topLevelConfig.logger.error(msg, { + ...opts, + environment: import_picocolors.default.red(environment) + }); + }, + clearScreen(type) { + return topLevelConfig.logger.clearScreen(type); + }, + hasErrorLogged(error) { + return topLevelConfig.logger.hasErrorLogged(error); + } + }; + } +}; +var BaseEnvironment = class extends PartialEnvironment { + get plugins() { + return this.config.plugins; + } + /** + * @internal + */ + _initiated = false; + constructor(name, config, options = config.environments[name]) { + super(name, config, options); + } +}; +//#endregion +//#region src/node/server/searchRoot.ts +const ROOT_FILES = ["pnpm-workspace.yaml", "lerna.json"]; +function hasWorkspacePackageJSON(root) { + const path = join(root, "package.json"); + if (!isFileReadable(path)) return false; + try { + return !!(JSON.parse(fs.readFileSync(path, "utf-8")) || {}).workspaces; + } catch { + return false; + } +} +function hasWorkspaceDenoJSON(root) { + for (const name of ["deno.json", "deno.jsonc"]) { + const path = join(root, name); + if (!isFileReadable(path)) continue; + try { + if ((JSON.parse(fs.readFileSync(path, "utf-8")) || {}).workspace) return true; + } catch {} + } + return false; +} +function hasRootFile(root) { + return ROOT_FILES.some((file) => fs.existsSync(join(root, file))); +} +function hasPackageJSON(root) { + const path = join(root, "package.json"); + return fs.existsSync(path); +} +/** +* Search up for the nearest `package.json` +*/ +function searchForPackageRoot(current, root = current) { + if (hasPackageJSON(current)) return current; + const dir = dirname(current); + if (!dir || dir === current) return root; + return searchForPackageRoot(dir, root); +} +/** +* Search up for the nearest workspace root +*/ +function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) { + if (hasRootFile(current)) return current; + if (hasWorkspacePackageJSON(current)) return current; + if (hasWorkspaceDenoJSON(current)) return current; + const dir = dirname(current); + if (!dir || dir === current) return root; + return searchForWorkspaceRoot(dir, root); +} +//#endregion +//#region src/node/plugins/manifest.ts +const endsWithJSRE = /\.[cm]?js$/; +function manifestPlugin() { + const getState = perEnvironmentState(() => { + return { + manifest: {}, + outputCount: 0, + reset() { + this.manifest = {}; + this.outputCount = 0; + } + }; + }); + return perEnvironmentPlugin("native:manifest", (environment) => { + if (!environment.config.build.manifest) return false; + const root = environment.config.root; + const outPath = environment.config.build.manifest === true ? ".vite/manifest.json" : environment.config.build.manifest; + const envs = {}; + function getChunkName(chunk) { + return getChunkOriginalFileName(chunk, root, false) ?? `_${path.basename(chunk.fileName)}`; + } + return [ + { + name: "native:manifest-envs", + buildStart() { + envs[environment.name] = this.environment; + } + }, + viteManifestPlugin({ + root, + outPath, + isOutputOptionsForLegacyChunks: environment.config.isOutputOptionsForLegacyChunks, + cssEntries() { + return Object.fromEntries([...cssEntriesMap.get(envs[environment.name]).values()].map(({ name, referenceId }) => { + return [referenceId, name]; + })); + } + }), + { + name: "native:manifest-compatible", + generateBundle(_, bundle) { + const asset = bundle[outPath]; + if (asset.type === "asset") { + let manifest; + for (const output of Object.values(bundle)) { + const importedCss = output.viteMetadata?.importedCss; + const importedAssets = output.viteMetadata?.importedAssets; + if (!importedCss?.size && !importedAssets?.size) continue; + manifest ??= JSON.parse(asset.source.toString()); + if (output.type === "chunk") { + const item = manifest[getChunkName(output)]; + if (!item) continue; + if (importedCss?.size) item.css = [...importedCss]; + if (importedAssets?.size) item.assets = [...importedAssets]; + } else if (output.type === "asset" && output.names.length > 0) { + const keys = output.originalFileNames.length > 0 ? output.originalFileNames : [`_${path.basename(output.fileName)}`]; + for (const key of keys) { + const item = manifest[key]; + if (!item) continue; + if (!(item.file && endsWithJSRE.test(item.file))) { + if (importedCss?.size) item.css = [...importedCss]; + if (importedAssets?.size) item.assets = [...importedAssets]; + } + } + } + } + const output = this.environment.config.build.rolldownOptions.output; + const outputLength = Array.isArray(output) ? output.length : 1; + if (manifest && outputLength === 1) { + asset.source = JSON.stringify(manifest, void 0, 2); + return; + } + const state = getState(this); + state.outputCount++; + state.manifest = Object.assign(state.manifest, manifest ?? JSON.parse(asset.source.toString())); + if (state.outputCount >= outputLength) { + asset.source = JSON.stringify(state.manifest, void 0, 2); + state.reset(); + } else delete bundle[outPath]; + } + } + } + ]; + }); +} +function getChunkOriginalFileName(chunk, root, isLegacy) { + if (chunk.facadeModuleId) { + let name = normalizePath(path.relative(root, chunk.facadeModuleId)); + if (isLegacy && !chunk.name.includes("-legacy")) { + const ext = path.extname(name); + const endPos = ext.length !== 0 ? -ext.length : void 0; + name = `${name.slice(0, endPos)}-legacy${ext}`; + } + return name.replace(/\0/g, ""); + } +} +//#endregion +//#region src/node/plugins/css.ts +var import_src = /* @__PURE__ */ __toESM(require_src(), 1); +const decoder = new TextDecoder(); +const _cssConfigDefaults = Object.freeze({ + /** @experimental */ + transformer: "postcss", + preprocessorMaxWorkers: true, + /** @experimental */ + devSourcemap: false +}); +const cssConfigDefaults = _cssConfigDefaults; +function resolveCSSOptions(options) { + const resolved = mergeWithDefaults(_cssConfigDefaults, options ?? {}); + if (resolved.transformer === "lightningcss") { + resolved.lightningcss ??= {}; + resolved.lightningcss.targets ??= convertTargets(ESBUILD_BASELINE_WIDELY_AVAILABLE_TARGET); + } + return resolved; +} +const cssModuleRE = new RegExp(`\\.module${CSS_LANGS_RE.source}`); +const directRequestRE = /[?&]direct\b/; +const htmlProxyRE$1 = /[?&]html-proxy\b/; +const htmlProxyIndexRE = /&index=(\d+)/; +const commonjsProxyRE = /[?&]commonjs-proxy/; +const inlineRE$2 = /[?&]inline\b/; +const inlineCSSRE$1 = /[?&]inline-css\b/; +const styleAttrRE = /[?&]style-attr\b/; +const functionCallRE = /^[A-Z_][.\w-]*\(/i; +const transformOnlyRE = /[?&]transform-only\b/; +const nonEscapedDoubleQuoteRe = /(? cssModuleRE.test(request); +const isDirectCSSRequest = (request) => CSS_LANGS_RE.test(request) && directRequestRE.test(request); +const isDirectRequest = (request) => directRequestRE.test(request); +const cssModulesCache = /* @__PURE__ */ new WeakMap(); +const removedPureCssFilesCache = /* @__PURE__ */ new WeakMap(); +const cssBundleNameCache = /* @__PURE__ */ new WeakMap(); +const postcssConfigCache = /* @__PURE__ */ new WeakMap(); +function encodePublicUrlsInCSS(config) { + return config.command === "build"; +} +const cssUrlAssetRE = /__VITE_CSS_URL__([\da-f]+)__/g; +/** +* Plugin applied before user plugins +*/ +function cssPlugin(config) { + const isBuild = config.command === "build"; + let moduleCache; + const idResolver = createBackCompatIdResolver(config, { + preferRelative: true, + tryIndex: false, + extensions: [] + }); + let preprocessorWorkerController; + if (config.css.transformer !== "lightningcss") resolvePostcssConfig(config).catch(() => {}); + return { + name: "vite:css", + buildStart() { + moduleCache = /* @__PURE__ */ new Map(); + cssModulesCache.set(config, moduleCache); + removedPureCssFilesCache.set(config, /* @__PURE__ */ new Map()); + preprocessorWorkerController = createPreprocessorWorkerController(normalizeMaxWorkers(config.css.preprocessorMaxWorkers)); + preprocessorWorkerControllerCache.set(config, preprocessorWorkerController); + }, + async buildEnd() { + await preprocessorWorkerController?.close(); + }, + load: { + filter: { id: CSS_LANGS_RE }, + handler(id) { + if (urlRE$1.test(id)) { + if (isModuleCSSRequest(id)) throw new Error(`?url is not supported with CSS modules. (tried to import ${JSON.stringify(id)})`); + if (isBuild) { + id = injectQuery(removeUrlQuery(id), "transform-only"); + return `import ${JSON.stringify(id)};export default "__VITE_CSS_URL__${Buffer.from(id).toString("hex")}__"`; + } + } + } + }, + transform: { + filter: { id: { + include: CSS_LANGS_RE, + exclude: [commonjsProxyRE, SPECIAL_QUERY_RE] + } }, + async handler(raw, id) { + const { environment } = this; + const resolveUrl = (url, importer) => idResolver(environment, url, importer); + const urlResolver = async (url, importer) => { + const decodedUrl = decodeURI(url); + if (checkPublicFile(decodedUrl, config)) if (encodePublicUrlsInCSS(config)) return [publicFileToBuiltUrl(decodedUrl, config), void 0]; + else return [joinUrlSegments(joinUrlSegments(config.server.origin ?? "", config.base), decodedUrl), void 0]; + const [id, fragment] = decodedUrl.split("#"); + let resolved = await resolveUrl(id, importer); + if (resolved) { + if (fragment) resolved += "#" + fragment; + let url = await fileToUrl$1(this, resolved); + if (!url.startsWith("data:") && this.environment.mode === "dev") { + const mod = [...this.environment.moduleGraph.getModulesByFile(resolved) ?? []].find((mod) => mod.type === "asset"); + if (mod?.lastHMRTimestamp) url = injectQuery(url, `t=${mod.lastHMRTimestamp}`); + } + return [url, cleanUrl(resolved)]; + } + if (config.command === "build") { + if (!(config.build.rolldownOptions.external ? resolveUserExternal(config.build.rolldownOptions.external, decodedUrl, id, false) : false)) config.logger.warnOnce(`\n${decodedUrl} referenced in ${id} didn't resolve at build time, it will remain unchanged to be resolved at runtime`); + } + return [url, void 0]; + }; + const { code: css, modules, deps, map } = await compileCSS(environment, id, raw, preprocessorWorkerController, urlResolver); + if (modules) moduleCache.set(id, modules); + if (deps) for (const file of deps) this.addWatchFile(file); + return { + code: css, + map + }; + } + } + }; +} +/** +* Plugin applied after user plugins +*/ +function cssPostPlugin(config) { + const styles = /* @__PURE__ */ new Map(); + let codeSplitEmitQueue = createSerialPromiseQueue(); + const urlEmitQueue = createSerialPromiseQueue(); + let pureCssChunks; + let hasEmitted = false; + let chunkCSSMap; + const rolldownOptionsOutput = config.build.rolldownOptions.output; + const assetFileNames = (Array.isArray(rolldownOptionsOutput) ? rolldownOptionsOutput[0] : rolldownOptionsOutput)?.assetFileNames; + const getCssAssetDirname = (cssAssetName, originalFileName) => { + const cssAssetNameDir = path.dirname(cssAssetName); + if (!assetFileNames) return path.join(config.build.assetsDir, cssAssetNameDir); + else if (typeof assetFileNames === "string") return path.join(path.dirname(assetFileNames), cssAssetNameDir); + else return path.dirname(assetFileNames({ + type: "asset", + name: cssAssetName, + names: [cssAssetName], + originalFileName, + originalFileNames: originalFileName ? [originalFileName] : [], + source: "/* vite internal call, ignore */" + })); + }; + function getCssBundleName() { + const cached = cssBundleNameCache.get(config); + if (cached) return cached; + const cssBundleName = config.build.lib ? resolveLibCssFilename(config.build.lib, config.root, config.packageCache) : defaultCssBundleName; + cssBundleNameCache.set(config, cssBundleName); + return cssBundleName; + } + return { + name: "vite:css-post", + renderStart() { + pureCssChunks = /* @__PURE__ */ new Set(); + hasEmitted = false; + chunkCSSMap = /* @__PURE__ */ new Map(); + codeSplitEmitQueue = createSerialPromiseQueue(); + }, + transform: { + filter: { id: { + include: CSS_LANGS_RE, + exclude: [commonjsProxyRE, SPECIAL_QUERY_RE] + } }, + async handler(css, id) { + css = stripBomTag(css); + const inlineCSS = inlineCSSRE$1.test(id); + const isHTMLProxy = htmlProxyRE$1.test(id); + if (inlineCSS && isHTMLProxy) { + if (styleAttrRE.test(id)) css = css.replace(/"/g, """); + const index = htmlProxyIndexRE.exec(id)?.[1]; + if (index == null) throw new Error(`HTML proxy index in "${id}" not found`); + addToHTMLProxyTransformResult(`${getHash(cleanUrl(id))}_${Number.parseInt(index)}`, css); + return { + code: `export default ''`, + map: { mappings: "" } + }; + } + const inlined = inlineRE$2.test(id); + const modules = cssModulesCache.get(config).get(id); + const modulesCode = modules && !inlined && dataToEsm(modules, { + namedExports: true, + preferConst: true + }); + if (config.command === "serve") { + const getContentWithSourcemap = async (content) => { + if (config.css.devSourcemap) { + const sourcemap = this.getCombinedSourcemap(); + if (sourcemap.mappings) await injectSourcesContent(sourcemap, cleanUrl(id), config.logger); + return getCodeWithSourcemap("css", content, sourcemap); + } + return content; + }; + if (isDirectCSSRequest(id)) return null; + if (inlined) return `export default ${JSON.stringify(css)}`; + if (this.environment.config.consumer === "server") return modulesCode || "export {}"; + const cssContent = await getContentWithSourcemap(css); + return { + code: [ + this.environment.config.isBundled ? `const { updateStyle: __vite__updateStyle, removeStyle: __vite__removeStyle } = import.meta.hot._internal` : `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(path.posix.join(config.base, CLIENT_PUBLIC_PATH))}`, + `const __vite__id = ${JSON.stringify(id)}`, + `const __vite__css = ${JSON.stringify(cssContent)}`, + `__vite__updateStyle(__vite__id, __vite__css)`, + `${modulesCode || "import.meta.hot.accept()"}`, + `import.meta.hot.prune(() => __vite__removeStyle(__vite__id))` + ].join("\n"), + map: { mappings: "" }, + moduleType: "js" + }; + } + if (!inlined) styles.set(id, css); + let code; + if (modulesCode) code = modulesCode; + else if (inlined) { + let content = css; + if (config.build.cssMinify) content = await minifyCSS(content, config, true, id); + code = `export default ${JSON.stringify(content)}`; + } else code = ""; + return { + code, + map: { mappings: "" }, + moduleSideEffects: modulesCode || inlined ? false : "no-treeshake", + moduleType: "js" + }; + } + }, + ...config.command === "build" ? { + async renderChunk(code, chunk, opts, meta) { + let chunkCSS; + const renderedModules = new Proxy({}, { get(_target, p) { + for (const name in meta.chunks) { + const module = meta.chunks[name].modules[p]; + if (module) return module; + } + } }); + const isJsChunkEmpty = code === "" && !chunk.isEntry; + let isPureCssChunk = chunk.exports.length === 0; + const ids = Object.keys(chunk.modules); + for (const id of ids) if (styles.has(id)) { + if (transformOnlyRE.test(id)) continue; + const cssScopeTo = this.getModuleInfo(id)?.meta?.vite?.cssScopeTo; + if (cssScopeTo && !isCssScopeToRendered(cssScopeTo, renderedModules)) continue; + if (cssModuleRE.test(id)) isPureCssChunk = false; + chunkCSS = (chunkCSS || "") + styles.get(id); + } else if (!isJsChunkEmpty) isPureCssChunk = false; + const publicAssetUrlMap = publicAssetUrlCache.get(config); + const resolveAssetUrlsInCss = (chunkCSS, cssAssetName, originalFileName) => { + const encodedPublicUrls = encodePublicUrlsInCSS(config); + const cssAssetDirname = encodedPublicUrls || config.base === "./" || config.base === "" ? slash(getCssAssetDirname(cssAssetName, originalFileName)) : void 0; + const toRelative = (filename) => { + const relativePath = normalizePath(path.relative(cssAssetDirname, filename)); + return relativePath[0] === "." ? relativePath : "./" + relativePath; + }; + chunkCSS = chunkCSS.replace(assetUrlRE, (_, fileHash, postfix = "") => { + const filename = this.getFileName(fileHash) + postfix; + chunk.viteMetadata.importedAssets.add(cleanUrl(filename)); + return encodeURIPath(toOutputFilePathInCss(filename, "asset", cssAssetName, "css", config, toRelative)); + }); + if (encodedPublicUrls) { + const relativePathToPublicFromCSS = normalizePath(path.relative(cssAssetDirname, "")); + chunkCSS = chunkCSS.replace(publicAssetUrlRE, (_, hash) => { + const publicUrl = publicAssetUrlMap.get(hash).slice(1); + return encodeURIPath(toOutputFilePathInCss(publicUrl, "public", cssAssetName, "css", config, () => `${relativePathToPublicFromCSS}/${publicUrl}`)); + }); + } + return chunkCSS; + }; + function ensureFileExt(name, ext) { + return normalizePath(path.format({ + ...path.parse(name), + base: void 0, + ext + })); + } + let s; + const urlEmitTasks = []; + if (code.includes("__VITE_CSS_URL__")) { + let match; + cssUrlAssetRE.lastIndex = 0; + while (match = cssUrlAssetRE.exec(code)) { + const [full, idHex] = match; + const id = Buffer.from(idHex, "hex").toString(); + const originalFileName = cleanUrl(id); + const cssAssetName = ensureFileExt(path.basename(originalFileName), ".css"); + if (!styles.has(id)) throw new Error(`css content for ${JSON.stringify(id)} was not found`); + let cssContent = styles.get(id); + cssContent = resolveAssetUrlsInCss(cssContent, cssAssetName, originalFileName); + urlEmitTasks.push({ + cssAssetName, + originalFileName, + content: cssContent, + start: match.index, + end: match.index + full.length + }); + } + } + await urlEmitQueue.run(async () => Promise.all(urlEmitTasks.map(async (info) => { + info.content = await finalizeCss(info.content, config); + }))); + if (urlEmitTasks.length > 0) { + const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(opts.format, config.isWorker); + s ||= new MagicString(code); + for (const { cssAssetName, originalFileName, content, start, end } of urlEmitTasks) { + const referenceId = this.emitFile({ + type: "asset", + name: cssAssetName, + originalFileName, + source: content + }); + const filename = this.getFileName(referenceId); + chunk.viteMetadata.importedAssets.add(cleanUrl(filename)); + const replacement = toOutputFilePathInJS(this.environment, filename, "asset", chunk.fileName, "js", toRelativeRuntime); + const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`; + s.update(start, end, replacementString); + } + } + if (chunkCSS !== void 0) { + if (isPureCssChunk && (opts.format === "es" || opts.format === "cjs")) pureCssChunks.add(chunk); + if (this.environment.config.build.cssCodeSplit) { + if ((opts.format === "es" || opts.format === "cjs") && !chunk.fileName.includes("-legacy")) { + const isEntry = chunk.isEntry && isPureCssChunk; + const cssFullAssetName = ensureFileExt(chunk.name, ".css"); + const cssAssetName = chunk.isEntry && (!chunk.facadeModuleId || !isCSSRequest(chunk.facadeModuleId)) ? path.basename(cssFullAssetName) : cssFullAssetName; + const originalFileName = getChunkOriginalFileName(chunk, config.root, this.environment.config.isOutputOptionsForLegacyChunks?.(opts) ?? false); + chunkCSS = resolveAssetUrlsInCss(chunkCSS, cssAssetName, originalFileName); + chunkCSS = await codeSplitEmitQueue.run(async () => { + return finalizeCss(chunkCSS, config); + }); + const referenceId = this.emitFile({ + type: "asset", + name: cssAssetName, + originalFileName, + source: chunkCSS + }); + if (isEntry) cssEntriesMap.get(this.environment).set(chunk.fileName, { + referenceId, + name: chunk.name + }); + chunk.viteMetadata.importedCss.add(this.getFileName(referenceId)); + } else if (this.environment.config.consumer === "client") { + chunkCSS = await finalizeCss(chunkCSS, config); + let cssString = JSON.stringify(chunkCSS); + cssString = renderAssetUrlInJS(this, chunk, opts, cssString)?.toString() || cssString; + const style = `__vite_style__`; + const injectCode = `var ${style} = document.createElement('style');${style}.textContent = ${cssString};document.head.appendChild(${style});`; + s ||= new MagicString(code); + injectInlinedCSS(s, this, code, opts.format, injectCode); + } + } else { + chunkCSS = resolveAssetUrlsInCss(chunkCSS, getCssBundleName(), defaultCssBundleName); + chunkCSSMap.set(chunk.fileName, chunkCSS); + } + } + if (s) if (config.build.sourcemap) return { + code: s.toString(), + map: s.generateMap({ hires: "boundary" }) + }; + else return { code: s.toString() }; + return null; + }, + augmentChunkHash(chunk) { + if (chunk.viteMetadata?.importedCss.size) { + let hash = ""; + for (const id of chunk.viteMetadata.importedCss) hash += id; + return hash; + } + } + } : {}, + async generateBundle(opts, bundle) { + if (this.environment.config.isOutputOptionsForLegacyChunks?.(opts)) return; + if ((config.command !== "build" || this.environment.config.build.emitAssets) && !this.environment.config.build.cssCodeSplit && !hasEmitted) { + let extractedCss = ""; + const collected = /* @__PURE__ */ new Set(); + const dynamicImports = /* @__PURE__ */ new Set(); + function collect(chunk) { + if (!chunk || chunk.type !== "chunk" || collected.has(chunk)) return; + collected.add(chunk); + chunk.imports.forEach((importName) => collect(bundle[importName])); + chunk.dynamicImports.forEach((importName) => dynamicImports.add(importName)); + extractedCss += chunkCSSMap.get(chunk.preliminaryFileName) ?? ""; + } + for (const chunk of Object.values(bundle)) if (chunk.type === "chunk" && chunk.isEntry) collect(chunk); + for (const chunkName of dynamicImports) collect(bundle[chunkName]); + if (extractedCss) { + hasEmitted = true; + extractedCss = await finalizeCss(extractedCss, config); + this.emitFile({ + name: getCssBundleName(), + type: "asset", + source: extractedCss, + originalFileName: defaultCssBundleName + }); + } + } + if (pureCssChunks.size) { + const prelimaryNameToChunkMap = Object.fromEntries(Object.values(bundle).filter((chunk) => chunk.type === "chunk").map((chunk) => [chunk.preliminaryFileName, chunk.fileName])); + const pureCssChunkNames = [...pureCssChunks].map((pureCssChunk) => prelimaryNameToChunkMap[pureCssChunk.fileName]).filter(Boolean); + let importMapReverseMapping; + if (config.build.chunkImportMap) { + const importMap = getImportMap(bundle, config); + importMapReverseMapping = Object.fromEntries(Object.entries(importMap.mapping).map(([k, v]) => [v, k])); + } + const replaceEmptyChunk = getEmptyChunkReplacer(importMapReverseMapping ? pureCssChunkNames.map((name) => importMapReverseMapping[name] ?? name) : pureCssChunkNames, opts.format); + for (const file in bundle) { + const chunk = bundle[file]; + if (chunk.type === "chunk") { + let chunkImportsPureCssChunk = false; + chunk.imports = chunk.imports.filter((file) => { + if (pureCssChunkNames.includes(file)) { + const { importedCss, importedAssets } = bundle[file].viteMetadata; + importedCss.forEach((file) => chunk.viteMetadata.importedCss.add(file)); + importedAssets.forEach((file) => chunk.viteMetadata.importedAssets.add(file)); + chunkImportsPureCssChunk = true; + return false; + } + return true; + }); + if (chunkImportsPureCssChunk) chunk.code = replaceEmptyChunk(chunk.code); + } + } + const removedPureCssFiles = removedPureCssFilesCache.get(config); + pureCssChunkNames.forEach((fileName) => { + const emptyJsPlaceholder = bundle[fileName]; + if (emptyJsPlaceholder.isEntry) { + const { importedAssets, importedCss } = emptyJsPlaceholder.viteMetadata; + const cssReferenceId = cssEntriesMap.get(this.environment).get(emptyJsPlaceholder.preliminaryFileName).referenceId; + const realCssEntryName = this.getFileName(cssReferenceId); + const realCssEntry = bundle[realCssEntryName]; + importedCss.delete(realCssEntryName); + if (importedAssets.size) realCssEntry.viteMetadata.importedAssets = importedAssets; + if (importedCss.size) realCssEntry.viteMetadata.importedCss = importedCss; + } + removedPureCssFiles.set(fileName, emptyJsPlaceholder); + delete bundle[fileName]; + delete bundle[`${fileName}.map`]; + }); + } + const cssAssets = Object.values(bundle).filter((asset) => asset.type === "asset" && asset.fileName.endsWith(".css")); + for (const cssAsset of cssAssets) if (typeof cssAsset.source === "string") cssAsset.source = cssAsset.source.replace(viteHashUpdateMarkerRE, ""); + } + }; +} +function injectInlinedCSS(s, ctx, code, format, injectCode) { + let injectionPoint; + if (format === "iife" || format === "umd") { + const m = (format === "iife" ? IIFE_BEGIN_RE : UMD_BEGIN_RE).exec(code); + if (!m) ctx.error("Injection point for inlined CSS not found"); + injectionPoint = m.index + m[0].length; + } else if (format === "es") if (code.startsWith("#!")) { + const newlinePos = code.indexOf("\n"); + if (newlinePos === -1) { + s.append(`\n${injectCode}`); + return; + } + injectionPoint = newlinePos + 1; + } else injectionPoint = 0; + else ctx.error("Non supported format"); + s.appendRight(injectionPoint, injectCode); +} +function cssAnalysisPlugin(config) { + return { + name: "vite:css-analysis", + applyToEnvironment(environment) { + return !environment.config.isBundled; + }, + transform: { + filter: { id: { + include: CSS_LANGS_RE, + exclude: [commonjsProxyRE, SPECIAL_QUERY_RE] + } }, + handler(_, id) { + const { moduleGraph } = this.environment; + const thisModule = moduleGraph.getModuleById(id); + if (thisModule) { + const isSelfAccepting = !cssModulesCache.get(config)?.get(id) && !inlineRE$2.test(id) && !htmlProxyRE$1.test(id); + const pluginImports = this._addedImports; + if (pluginImports) { + const depModules = /* @__PURE__ */ new Set(); + for (const file of pluginImports) depModules.add(moduleGraph.createFileOnlyEntry(file)); + moduleGraph.updateModuleInfo(thisModule, depModules, null, /* @__PURE__ */ new Set(), null, isSelfAccepting); + } else thisModule.isSelfAccepting = isSelfAccepting; + } + } + } + }; +} +function isCssScopeToRendered(cssScopeTo, renderedModules) { + const [importerId, exp] = cssScopeTo; + const importer = renderedModules[importerId]; + return importer && (exp === void 0 || importer.renderedExports.includes(exp)); +} +/** +* Create a replacer function that takes code and replaces given pure CSS chunk imports +* @param pureCssChunkNames The chunks that only contain pure CSS and should be replaced +* @param outputFormat The module output format to decide whether to replace `import` or `require` +*/ +function getEmptyChunkReplacer(pureCssChunkNames, outputFormat) { + const emptyChunkFiles = pureCssChunkNames.map((file) => escapeRegex(path.basename(file))).join("|"); + const emptyChunkRE = new RegExp(outputFormat === "es" ? `\\bimport\\s*["'][^"']*(?:${emptyChunkFiles})["'];` : `(\\b|,\\s*)require\\(\\s*["'\`][^"'\`]*(?:${emptyChunkFiles})["'\`]\\)(;|,)`, "g"); + return (code) => code.replace(emptyChunkRE, (m, p1, p2) => { + if (outputFormat === "es") return `/* empty css ${"".padEnd(m.length - 15)}*/`; + if (p2 === ";") return `${p2}/* empty css ${"".padEnd(m.length - 16)}*/`; + return `${p1}/* empty css ${"".padEnd(m.length - 15 - p1.length)}*/`; + }); +} +const fileURLWithWindowsDriveRE = /^file:\/\/\/[a-zA-Z]:\//; +function createCSSResolvers(config) { + let cssResolve; + let sassResolve; + let lessResolve; + return { + get css() { + return cssResolve ??= createBackCompatIdResolver(config, { + extensions: [".css"], + mainFields: ["style"], + conditions: ["style", DEV_PROD_CONDITION], + tryIndex: false, + preferRelative: true + }); + }, + get sass() { + if (!sassResolve) { + const resolver = createBackCompatIdResolver(config, { + extensions: [ + ".scss", + ".sass", + ".css" + ], + mainFields: ["sass", "style"], + conditions: [ + "sass", + "style", + DEV_PROD_CONDITION + ], + tryIndex: true, + tryPrefix: "_", + preferRelative: true, + skipMainField: true + }); + sassResolve = async (...args) => { + if (args[1].startsWith("file://")) args[1] = fileURLToPath(args[1], { windows: isWindows && !fileURLWithWindowsDriveRE.test(args[1]) ? false : void 0 }); + return resolver(...args); + }; + } + return sassResolve; + }, + get less() { + return lessResolve ??= createBackCompatIdResolver(config, { + extensions: [".less", ".css"], + mainFields: ["less", "style"], + conditions: [ + "less", + "style", + DEV_PROD_CONDITION + ], + tryIndex: false, + preferRelative: true + }); + } + }; +} +function getCssResolversKeys(resolvers) { + return Object.keys(resolvers); +} +async function compileCSSPreprocessors(environment, id, lang, code, workerController) { + const { config } = environment; + const { preprocessorOptions, devSourcemap } = config.css; + const atImportResolvers = getAtImportResolvers(environment.getTopLevelConfig()); + const opts = { + ...preprocessorOptions && preprocessorOptions[lang] || {}, + filename: cleanUrl(id), + enableSourcemap: devSourcemap ?? false + }; + const preProcessor = workerController[lang]; + const preprocessResult = await preProcessor(environment, code, config.root, opts, atImportResolvers); + if (preprocessResult.error) throw preprocessResult.error; + let deps; + if (preprocessResult.deps.length > 0) { + const normalizedFilename = normalizePath(opts.filename); + deps = new Set([...preprocessResult.deps].filter((dep) => normalizePath(dep) !== normalizedFilename)); + } + return { + code: preprocessResult.code, + map: combineSourcemapsIfExists(opts.filename, preprocessResult.map, preprocessResult.additionalMap), + deps + }; +} +const configToAtImportResolvers = /* @__PURE__ */ new WeakMap(); +function getAtImportResolvers(config) { + let atImportResolvers = configToAtImportResolvers.get(config); + if (!atImportResolvers) { + atImportResolvers = createCSSResolvers(config); + configToAtImportResolvers.set(config, atImportResolvers); + } + return atImportResolvers; +} +async function compileCSS(environment, id, code, workerController, urlResolver) { + const { config } = environment; + const lang = CSS_LANGS_RE.exec(id)?.[1]; + const deps = /* @__PURE__ */ new Set(); + let preprocessorMap; + if (isPreProcessor(lang)) { + const preprocessorResult = await compileCSSPreprocessors(environment, id, lang, code, workerController); + code = preprocessorResult.code; + preprocessorMap = preprocessorResult.map; + preprocessorResult.deps?.forEach((dep) => deps.add(dep)); + } else if (lang === "sss" && config.css.transformer === "lightningcss") { + const sssResult = await transformSugarSS(environment, id, code); + code = sssResult.code; + preprocessorMap = sssResult.map; + } + const transformResult = await (config.css.transformer === "lightningcss" ? compileLightningCSS(environment, id, code, deps, workerController, urlResolver) : compilePostCSS(environment, id, code, deps, lang, workerController, urlResolver)); + if (!transformResult) return { + code, + map: config.css.devSourcemap ? preprocessorMap : { mappings: "" }, + deps + }; + return { + ...transformResult, + map: config.css.devSourcemap ? combineSourcemapsIfExists(cleanUrl(id), typeof transformResult.map === "string" ? JSON.parse(transformResult.map) : transformResult.map, preprocessorMap) : { mappings: "" }, + deps + }; +} +async function compilePostCSS(environment, id, code, deps, lang, workerController, urlResolver) { + const { config } = environment; + const { modules: modulesOptions, devSourcemap } = config.css; + const isModule = modulesOptions !== false && cssModuleRE.test(id); + const needInlineImport = code.includes("@import"); + const hasUrl = cssUrlRE.test(code) || cssImageSetRE.test(code); + const postcssConfig = await resolvePostcssConfig(environment.getTopLevelConfig()); + if (lang !== "sss" && !postcssConfig && !isModule && !needInlineImport && !hasUrl) return; + const atImportResolvers = getAtImportResolvers(environment.getTopLevelConfig()); + const postcssPlugins = postcssConfig?.plugins.slice() ?? []; + if (needInlineImport) postcssPlugins.unshift((await importPostcssImport()).default({ + async resolve(id, basedir, _importOptions, atRule) { + const publicFile = checkPublicFile(id, environment.getTopLevelConfig()); + if (publicFile) return publicFile; + const resolved = await atImportResolvers.css(environment, id, atRule.source?.input.file); + if (resolved) return path.resolve(resolved); + if (!path.isAbsolute(id)) environment.logger.error(import_picocolors.default.red(`Unable to resolve \`@import "${id}"\` from ${basedir}`)); + return id; + }, + async load(id) { + const code = await fs.promises.readFile(id, "utf-8"); + const lang = CSS_LANGS_RE.exec(id)?.[1]; + if (isPreProcessor(lang)) { + const result = await compileCSSPreprocessors(environment, id, lang, code, workerController); + result.deps?.forEach((dep) => deps.add(dep)); + return result.code; + } + return code; + }, + nameLayer(index) { + return `vite--anon-layer-${getHash(id)}-${index}`; + } + })); + if (urlResolver && (postcssPlugins.length > 0 || isModule || hasUrl)) postcssPlugins.push(UrlRewritePostcssPlugin({ + resolver: urlResolver, + deps, + logger: environment.logger + })); + let modules; + if (isModule) postcssPlugins.unshift((await importPostcssModules()).default({ + ...modulesOptions, + localsConvention: modulesOptions?.localsConvention, + getJSON(cssFileName, _modules, outputFileName) { + modules = _modules; + if (modulesOptions && typeof modulesOptions.getJSON === "function") modulesOptions.getJSON(cssFileName, _modules, outputFileName); + }, + async resolve(id, importer) { + for (const key of getCssResolversKeys(atImportResolvers)) { + const resolved = await atImportResolvers[key](environment, id, importer); + if (resolved) return path.resolve(resolved); + } + return id; + } + })); + const postcssOptions = postcssConfig?.options ?? {}; + const postcssParser = lang === "sss" ? await loadSss(config.root) : postcssOptions.parser; + if (!postcssPlugins.length && !postcssParser) return; + return { + ...await runPostCSS(id, code, postcssPlugins, { + ...postcssOptions, + parser: postcssParser + }, deps, environment.logger, devSourcemap), + modules + }; +} +async function transformSugarSS(environment, id, code) { + const { config } = environment; + const { devSourcemap } = config.css; + return await runPostCSS(id, code, [], { parser: await loadSss(config.root) }, void 0, environment.logger, devSourcemap); +} +async function runPostCSS(id, code, plugins, options, deps, logger, enableSourcemap) { + let postcssResult; + try { + const source = removeDirectQuery(id); + postcssResult = await (await importPostcss()).default(plugins).process(code, { + ...options, + to: source, + from: source, + ...enableSourcemap ? { map: { + inline: false, + annotation: false, + sourcesContent: true + } } : {} + }); + for (const message of postcssResult.messages) if (message.type === "dependency") deps?.add(normalizePath(message.file)); + else if (message.type === "dir-dependency") { + const { dir, glob: globPattern = "**" } = message; + const files = globSync(globPattern, { + absolute: true, + cwd: path.resolve(path.dirname(id), dir), + expandDirectories: false, + ignore: ["**/node_modules/**"] + }); + for (let i = 0; i < files.length; i++) deps?.add(files[i]); + } else if (message.type === "warning") { + const warning = message; + let msg = `[vite:css][postcss] ${warning.text}`; + msg += `\n${generateCodeFrame(code, { + line: warning.line, + column: warning.column - 1 + }, warning.endLine !== void 0 && warning.endColumn !== void 0 ? { + line: warning.endLine, + column: warning.endColumn - 1 + } : void 0)}`; + logger.warn(import_picocolors.default.yellow(msg)); + } + } catch (e) { + e.message = `[postcss] ${e.message}`; + e.code = code; + e.loc = { + file: e.file, + line: e.line, + column: e.column - 1 + }; + throw e; + } + if (!enableSourcemap) return { + code: postcssResult.css, + map: { mappings: "" } + }; + const postcssMap = await formatPostcssSourceMap(postcssResult.map.toJSON(), cleanUrl(id)); + return { + code: postcssResult.css, + map: postcssMap + }; +} +function createCachedImport(imp) { + let cached; + return () => { + if (!cached) cached = imp().then((module) => { + cached = module; + return module; + }); + return cached; + }; +} +const importPostcssImport = createCachedImport(() => import("./postcss-import.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1))); +const importPostcssModules = createCachedImport(() => import("./build.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1))); +const importPostcss = createCachedImport(() => import("postcss")); +const preprocessorWorkerControllerCache = /* @__PURE__ */ new WeakMap(); +let alwaysFakeWorkerWorkerControllerCache; +/** +* @experimental +*/ +async function preprocessCSS(code, filename, config) { + let workerController = preprocessorWorkerControllerCache.get(config); + if (!workerController) { + alwaysFakeWorkerWorkerControllerCache ||= createPreprocessorWorkerController(0); + workerController = alwaysFakeWorkerWorkerControllerCache; + } + return await compileCSS(new PartialEnvironment("client", config), filename, code, workerController); +} +async function formatPostcssSourceMap(rawMap, file) { + const inputFileDir = path.dirname(file); + const sources = rawMap.sources.map((source) => { + const cleanSource = cleanUrl(decodeURIComponent(source)); + if (cleanSource[0] === "<" && cleanSource.endsWith(">")) return `\0${cleanSource}`; + return normalizePath(path.resolve(inputFileDir, cleanSource)); + }); + return { + file, + mappings: rawMap.mappings, + names: rawMap.names, + sources, + sourcesContent: rawMap.sourcesContent, + version: rawMap.version + }; +} +function combineSourcemapsIfExists(filename, map1, map2) { + if (!map1 || !map2) return map1; + if (map1.mappings === "" || map2.mappings === "") return { mappings: "" }; + return combineSourcemaps(filename, [map1, map2]); +} +const viteHashUpdateMarker = "/*$vite$:1*/"; +const viteHashUpdateMarkerRE = /\/\*\$vite\$:\d+\*\//; +async function finalizeCss(css, config) { + if (css.includes("@import") || css.includes("@charset")) css = hoistAtRules(css); + if (config.build.cssMinify) css = await minifyCSS(css, config, false); + css += viteHashUpdateMarker; + return css; +} +async function resolvePostcssConfig(config) { + let result = postcssConfigCache.get(config); + if (result !== void 0) return await result; + const inlineOptions = config.css.postcss; + if (isObject$1(inlineOptions)) { + const options = { ...inlineOptions }; + delete options.plugins; + result = { + options, + plugins: inlineOptions.plugins || [] + }; + } else { + const searchPath = typeof inlineOptions === "string" ? inlineOptions : config.root; + result = (0, import_src.default)({}, searchPath, { stopDir: searchForWorkspaceRoot(config.root) }).catch((e) => { + if (!e.message.includes("No PostCSS Config found")) if (e instanceof Error) { + const { name, message, stack } = e; + e.name = "Failed to load PostCSS config"; + e.message = `Failed to load PostCSS config (searchPath: ${searchPath}): [${name}] ${message}\n${stack}`; + e.stack = ""; + throw e; + } else throw new Error(`Failed to load PostCSS config: ${e}`); + return null; + }); + result.then((resolved) => { + postcssConfigCache.set(config, resolved); + }, () => {}); + } + postcssConfigCache.set(config, result); + return result; +} +const cssUrlRE = /(? { + if (!opts) throw new Error("base or replace is required"); + return { + postcssPlugin: "vite-url-rewrite", + Once(root) { + const promises = []; + root.walkDecls((declaration) => { + const importer = declaration.source?.input.file; + if (!importer) opts.logger.warnOnce("\nA PostCSS plugin did not pass the `from` option to `postcss.parse`. This may cause imported assets to be incorrectly transformed. If you've recently added a PostCSS plugin that raised this warning, please contact the package author to fix the issue."); + const isCssUrl = cssUrlRE.test(declaration.value); + const isCssImageSet = cssImageSetRE.test(declaration.value); + if (isCssUrl || isCssImageSet) { + const replacerForDeclaration = async (rawUrl) => { + const [newUrl, resolvedId] = await opts.resolver(rawUrl, importer); + if (resolvedId) opts.deps.add(resolvedId); + return newUrl; + }; + if (isCssUrl && isCssImageSet) promises.push(rewriteCssUrls(declaration.value, replacerForDeclaration).then((url) => rewriteCssImageSet(url, replacerForDeclaration)).then((url) => { + declaration.value = url; + })); + else promises.push((isCssImageSet ? rewriteCssImageSet : rewriteCssUrls)(declaration.value, replacerForDeclaration).then((url) => { + declaration.value = url; + })); + } + }); + if (promises.length) return Promise.all(promises); + } + }; +}; +UrlRewritePostcssPlugin.postcss = true; +function rewriteCssUrls(css, replacer) { + return asyncReplace(css, cssUrlRE, async (match) => { + const [matched, rawUrl] = match; + return await doUrlReplace(rawUrl.trim(), matched, replacer); + }); +} +function rewriteCssDataUris(css, replacer) { + return asyncReplace(css, cssDataUriRE, async (match) => { + const [matched, rawUrl] = match; + return await doUrlReplace(rawUrl.trim(), matched, replacer, "data-uri"); + }); +} +function rewriteImportCss(css, replacer) { + return asyncReplace(css, importCssRE, async (match) => { + const [matched, rawUrl] = match; + return await doImportCSSReplace(rawUrl, matched, replacer); + }); +} +const cssNotProcessedRE = /(?:gradient|element|cross-fade|image)\(/; +async function rewriteCssImageSet(css, replacer) { + return await asyncReplace(css, cssImageSetRE, async (match) => { + const [, rawUrl] = match; + return await processSrcSet(rawUrl, async ({ url }) => { + if (cssUrlRE.test(url)) return await rewriteCssUrls(url, replacer); + if (!cssNotProcessedRE.test(url)) return await doUrlReplace(url, url, replacer); + return url; + }); + }); +} +function skipUrlReplacer(unquotedUrl) { + return isExternalUrl(unquotedUrl) || isDataUrl(unquotedUrl) || unquotedUrl[0] === "#" || functionCallRE.test(unquotedUrl) || unquotedUrl.startsWith("__VITE_ASSET__") || unquotedUrl.startsWith("__VITE_PUBLIC_ASSET__"); +} +async function doUrlReplace(rawUrl, matched, replacer, funcName = "url") { + let wrap = ""; + const first = rawUrl[0]; + let unquotedUrl = rawUrl; + if (first === `"` || first === `'`) { + wrap = first; + unquotedUrl = rawUrl.slice(1, -1); + } + if (skipUrlReplacer(unquotedUrl)) return matched; + unquotedUrl = unquotedUrl.replace(/\\(\W)/g, "$1"); + let newUrl = await replacer(unquotedUrl, rawUrl); + if (newUrl === false) return matched; + if (wrap === "" && (newUrl !== encodeURI(newUrl) || newUrl.includes(")"))) wrap = "\""; + if (wrap === "'" && newUrl.includes("'")) wrap = "\""; + if (wrap === "\"" && newUrl.includes("\"")) newUrl = newUrl.replace(nonEscapedDoubleQuoteRe, "\\\""); + return `${funcName}(${wrap}${newUrl}${wrap})`; +} +async function doImportCSSReplace(rawUrl, matched, replacer) { + let wrap = ""; + const first = rawUrl[0]; + let unquotedUrl = rawUrl; + if (first === `"` || first === `'`) { + wrap = first; + unquotedUrl = rawUrl.slice(1, -1); + } + if (skipUrlReplacer(unquotedUrl)) return matched; + const newUrl = await replacer(unquotedUrl, rawUrl); + if (newUrl === false) return matched; + return `@import ${matched.includes("url(") ? "url(" : ""}${wrap}${newUrl}${wrap}`; +} +async function minifyCSS(css, config, inlined, filename = defaultCssBundleName) { + if (config.build.cssMinify === "esbuild") { + const { transform, formatMessages } = await importEsbuild(); + try { + const { code, warnings } = await transform(css, { + loader: "css", + target: config.build.cssTarget || void 0, + sourcefile: filename, + ...resolveMinifyCssEsbuildOptions(config.esbuild || {}) + }); + if (warnings.length) { + const msgs = await formatMessages(warnings, { kind: "warning" }); + config.logger.warn(import_picocolors.default.yellow(`[esbuild css minify]\n${msgs.join("\n")}`)); + } + return inlined ? code.trimEnd() : code; + } catch (e) { + if (e.errors) { + e.message = "[esbuild css minify] " + e.message; + e.frame = "\n" + (await formatMessages(e.errors, { kind: "error" })).join("\n"); + e.loc = e.errors[0].location; + } + throw e; + } + } + try { + const { code, warnings } = (await importLightningCSS()).transform({ + ...config.css.lightningcss, + targets: convertTargets(config.build.cssTarget), + cssModules: void 0, + filename, + code: Buffer.from(css), + minify: true + }); + for (const warning of warnings) { + let msg = `[lightningcss minify] ${warning.message}`; + msg += `\n${generateCodeFrame(css, { + line: warning.loc.line, + column: warning.loc.column - 1 + })}`; + config.logger.warn(import_picocolors.default.yellow(msg)); + } + return decoder.decode(code) + (inlined ? "" : "\n"); + } catch (e) { + e.message = `[lightningcss minify] ${e.message}`; + const friendlyMessage = getLightningCssErrorMessageForIeSyntaxes(css); + if (friendlyMessage) e.message += friendlyMessage; + if (e.loc) { + e.loc = { + line: e.loc.line, + column: e.loc.column - 1 + }; + e.frame = generateCodeFrame(css, e.loc); + } + throw e; + } +} +function resolveMinifyCssEsbuildOptions(options) { + const base = { + charset: options.charset, + logLevel: options.logLevel, + logLimit: options.logLimit, + logOverride: options.logOverride, + legalComments: options.legalComments + }; + if (options.minifyIdentifiers != null || options.minifySyntax != null || options.minifyWhitespace != null) return { + ...base, + minifyIdentifiers: options.minifyIdentifiers ?? true, + minifySyntax: options.minifySyntax ?? true, + minifyWhitespace: options.minifyWhitespace ?? true + }; + else return { + ...base, + minify: true + }; +} +const atImportRE = /@import(?:\s*(?:url\([^)]*\)|"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g; +const atCharsetRE = /@charset(?:\s*(?:"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g; +function hoistAtRules(css) { + const s = new MagicString(css); + const cleanCss = emptyCssComments(css); + let match; + atImportRE.lastIndex = 0; + while (match = atImportRE.exec(cleanCss)) { + s.remove(match.index, match.index + match[0].length); + s.appendLeft(0, match[0]); + } + atCharsetRE.lastIndex = 0; + let foundCharset = false; + while (match = atCharsetRE.exec(cleanCss)) { + s.remove(match.index, match.index + match[0].length); + if (!foundCharset) { + s.prepend(match[0]); + foundCharset = true; + } + } + return s.toString(); +} +const loadedPreprocessorPath = {}; +function loadPreprocessorPath(lang, root) { + const cached = loadedPreprocessorPath[lang]; + if (cached) return cached; + const resolved = nodeResolveWithVite(lang, void 0, { root }) ?? nodeResolveWithVite(lang, _dirname, { root }); + if (resolved) return loadedPreprocessorPath[lang] = resolved; + const installCommand = getPackageManagerCommand("install"); + throw new Error(`Preprocessor dependency "${lang}" not found. Did you install it? Try \`${installCommand} -D ${lang}\`.`); +} +function loadSassPackage(root, skipEmbedded = false) { + if (!skipEmbedded) try { + return { + name: "sass-embedded", + path: loadPreprocessorPath("sass-embedded", root) + }; + } catch (e1) { + try { + return { + name: "sass", + path: loadPreprocessorPath("sass", root) + }; + } catch { + throw e1; + } + } + return { + name: "sass", + path: loadPreprocessorPath("sass", root) + }; +} +let cachedSss; +async function loadSss(root) { + if (!cachedSss) cachedSss = (async () => { + return cachedSss = (await import(pathToFileURL(loadPreprocessorPath("sugarss", root)).href)).default; + })(); + return cachedSss; +} +function cleanScssBugUrl(url) { + if (typeof window !== "undefined" && typeof location !== "undefined" && typeof location.href === "string") { + const prefix = location.href.replace(/\/$/, ""); + return url.replace(prefix, ""); + } else return url; +} +const makeScssWorker = (environment, resolvers, _maxWorkers) => { + let compilerPromise; + return { + async run(sassPath, data, options) { + const sass = await import(sassPath); + compilerPromise ??= sass.initAsyncCompiler(); + const compiler = await compilerPromise; + const sassOptions = { ...options }; + sassOptions.url = pathToFileURL(options.filename); + sassOptions.sourceMap = options.enableSourcemap; + const skipRebaseUrls = (unquotedUrl, rawUrl) => { + if (!(rawUrl[0] === "\"" || rawUrl[0] === "'") && unquotedUrl[0] === "$") return true; + return unquotedUrl.startsWith("#{"); + }; + const internalImporter = { + async canonicalize(url, context) { + const importer = context.containingUrl ? fileURLToPath(context.containingUrl) : options.filename; + const resolved = await resolvers.sass(environment, url, cleanScssBugUrl(importer)); + if (resolved && (resolved.endsWith(".css") || resolved.endsWith(".scss") || resolved.endsWith(".sass"))) return pathToFileURL(resolved); + return null; + }, + async load(canonicalUrl) { + const ext = path.extname(canonicalUrl.pathname); + let syntax = "scss"; + if (ext === ".sass") syntax = "indented"; + else if (ext === ".css") syntax = "css"; + const result = await rebaseUrls(environment, fileURLToPath(canonicalUrl), options.filename, resolvers.sass, skipRebaseUrls); + return { + contents: result.contents ?? await fsp.readFile(result.file, "utf-8"), + syntax, + sourceMapUrl: canonicalUrl + }; + } + }; + sassOptions.importers = [...sassOptions.importers ?? [], internalImporter]; + sassOptions.importer ??= internalImporter; + const result = await compiler.compileStringAsync(data, sassOptions); + return { + css: result.css, + map: result.sourceMap ? JSON.stringify(result.sourceMap) : void 0, + stats: { includedFiles: result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath(url)) } + }; + }, + async stop() { + await (await compilerPromise)?.dispose(); + compilerPromise = void 0; + } + }; +}; +const scssProcessor = (maxWorkers) => { + let worker; + let failedSassEmbedded; + const normalizedErrors = /* @__PURE__ */ new WeakSet(); + return { + async close() { + await worker?.stop(); + }, + async process(environment, source, root, options, resolvers) { + let sassPackage = loadSassPackage(root, failedSassEmbedded ?? false); + if (failedSassEmbedded === void 0) { + failedSassEmbedded = false; + try { + await import(sassPackage.path); + } catch (e) { + if (/sass-embedded-[a-z0-9]+-[a-z0-9]+/i.test(e.message)) { + failedSassEmbedded = true; + sassPackage = loadSassPackage(root, failedSassEmbedded); + } + } + } + worker ??= makeScssWorker(environment, resolvers, maxWorkers); + const { content: data, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap); + const optionsWithoutAdditionalData = { + ...options, + additionalData: void 0 + }; + try { + const result = await worker.run(pathToFileURL(sassPackage.path).href, data, optionsWithoutAdditionalData); + const deps = result.stats.includedFiles.map((f) => cleanScssBugUrl(f)); + const map = result.map ? JSON.parse(result.map.toString()) : void 0; + if (map) map.sources = map.sources.map((url) => url.startsWith("file://") ? normalizePath(fileURLToPath(url)) : url); + return { + code: result.css.toString(), + map, + additionalMap, + deps + }; + } catch (e) { + if (!normalizedErrors.has(e)) { + e.message = `[sass] ${e.message}`; + e.id = e.file; + e.frame = e.formatted; + if (e.span?.start) { + e.line = e.span.start.line + 1; + e.column = e.span.start.column + 1; + e.frame = e.message; + } + normalizedErrors.add(e); + } + return { + code: "", + error: e, + deps: [] + }; + } + } + }; +}; +/** +* relative url() inside \@imported sass and less files must be rebased to use +* root file as base. +*/ +async function rebaseUrls(environment, file, rootFile, resolver, ignoreUrl) { + file = path.resolve(file); + const fileDir = path.dirname(file); + const rootDir = path.dirname(rootFile); + if (fileDir === rootDir) return { file }; + const content = await fsp.readFile(file, "utf-8"); + const hasUrls = cssUrlRE.test(content); + const hasDataUris = cssDataUriRE.test(content); + const hasImportCss = importCssRE.test(content); + if (!hasUrls && !hasDataUris && !hasImportCss) return { file }; + let rebased; + const rebaseFn = async (unquotedUrl, rawUrl) => { + if (ignoreUrl?.(unquotedUrl, rawUrl)) return false; + if (unquotedUrl[0] === "/") return unquotedUrl; + const absolute = await resolver(environment, unquotedUrl, file) || path.resolve(fileDir, unquotedUrl); + return normalizePath(path.relative(rootDir, absolute)); + }; + if (hasImportCss) rebased = await rewriteImportCss(content, rebaseFn); + if (hasUrls) rebased = await rewriteCssUrls(rebased || content, rebaseFn); + if (hasDataUris) rebased = await rewriteCssDataUris(rebased || content, rebaseFn); + return { + file, + contents: rebased + }; +} +const makeLessWorker = (environment, resolvers, maxWorkers) => { + const skipRebaseUrls = (unquotedUrl, _rawUrl) => { + return unquotedUrl[0] === "@"; + }; + const viteLessResolve = async (filename, dir, rootFile, mime) => { + const resolved = await resolvers.less(environment, filename, path.join(dir, "*")); + if (!resolved) return void 0; + if (mime === "application/javascript") return { resolved: path.resolve(resolved) }; + const result = await rebaseUrls(environment, resolved, rootFile, resolvers.less, skipRebaseUrls); + return { + resolved, + contents: "contents" in result ? result.contents : void 0 + }; + }; + return new WorkerWithFallback(async () => { + const [fsp, path] = await Promise.all([import("node:fs/promises"), import("node:path")]); + let ViteLessManager; + const createViteLessPlugin = (less, rootFile) => { + const { FileManager } = less; + ViteLessManager ??= class ViteManager extends FileManager { + rootFile; + constructor(rootFile) { + super(); + this.rootFile = rootFile; + } + supports(filename) { + return !/^(?:https?:)?\/\//.test(filename); + } + supportsSync() { + return false; + } + async loadFile(filename, dir, opts, env) { + const result = await viteLessResolve(filename, dir, this.rootFile, opts.mime); + if (result) return { + filename: path.resolve(result.resolved), + contents: result.contents ?? await fsp.readFile(result.resolved, "utf-8") + }; + else return super.loadFile(filename, dir, opts, env); + } + }; + return { + install(_, pluginManager) { + pluginManager.addFileManager(new ViteLessManager(rootFile)); + }, + minVersion: [ + 3, + 0, + 0 + ] + }; + }; + return async (lessPath, content, options) => { + const nodeLess = (await import(lessPath)).default; + const viteResolverPlugin = createViteLessPlugin(nodeLess, options.filename); + return await nodeLess.render(content, { + paths: ["node_modules"], + ...options, + plugins: [viteResolverPlugin, ...options.plugins || []], + ...options.enableSourcemap ? { sourceMap: { + outputSourceFiles: true, + disableSourcemapAnnotation: true, + sourceMapFileInline: false + } } : {} + }); + }; + }, { + parentFunctions: { viteLessResolve }, + shouldUseFake(_lessPath, _content, options) { + return !!options.plugins && options.plugins.length > 0; + }, + max: maxWorkers + }); +}; +const lessProcessor = (maxWorkers) => { + let worker; + return { + close() { + worker?.stop(); + }, + async process(environment, source, root, options, resolvers) { + const lessPath = loadPreprocessorPath("less", root); + worker ??= makeLessWorker(environment, resolvers, maxWorkers); + const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap); + let result; + const optionsWithoutAdditionalData = { + ...options, + additionalData: void 0 + }; + try { + result = await worker.run(pathToFileURL(lessPath).href, content, optionsWithoutAdditionalData); + } catch (e) { + const error = e; + const normalizedError = /* @__PURE__ */ new Error(`[less] ${error.message || error.type}`); + normalizedError.loc = { + file: error.filename || options.filename, + line: error.line, + column: error.column + }; + return { + code: "", + error: normalizedError, + deps: [] + }; + } + const map = result.map && JSON.parse(result.map); + if (map) delete map.sourcesContent; + return { + code: result.css.toString(), + map, + additionalMap, + deps: result.imports + }; + } + }; +}; +const makeStylWorker = (maxWorkers) => { + return new WorkerWithFallback(() => { + return async (stylusPath, content, root, options) => { + const stylus = (await import(stylusPath)).default; + const ref = stylus(content, { + paths: ["node_modules"], + ...options + }); + if (options.define) for (const key in options.define) ref.define(key, options.define[key]); + if (options.enableSourcemap) ref.set("sourcemap", { + comment: false, + inline: false, + basePath: root + }); + return { + code: ref.render(), + map: ref.sourcemap, + deps: ref.deps() + }; + }; + }, { + shouldUseFake(_stylusPath, _content, _root, options) { + return !!(options.define && Object.values(options.define).some((d) => typeof d === "function") || options.Evaluator); + }, + max: maxWorkers + }); +}; +const stylProcessor = (maxWorkers) => { + let worker; + return { + close() { + worker?.stop(); + }, + async process(_environment, source, root, options, _resolvers) { + const stylusPath = loadPreprocessorPath("stylus", root); + worker ??= makeStylWorker(maxWorkers); + const { content, map: additionalMap } = await getSource(source, options.filename, options.additionalData, options.enableSourcemap, "\n"); + const importsDeps = (options.imports ?? []).map((dep) => path.resolve(dep)); + const optionsWithoutAdditionalData = { + ...options, + additionalData: void 0 + }; + try { + const { code, map, deps } = await worker.run(pathToFileURL(stylusPath).href, content, root, optionsWithoutAdditionalData); + return { + code, + map: formatStylusSourceMap(map, root), + additionalMap, + deps: [...deps, ...importsDeps] + }; + } catch (e) { + const wrapped = /* @__PURE__ */ new Error(`[stylus] ${e.message}`); + wrapped.name = e.name; + wrapped.stack = e.stack; + return { + code: "", + error: wrapped, + deps: [] + }; + } + } + }; +}; +function formatStylusSourceMap(mapBefore, root) { + if (!mapBefore) return void 0; + const map = { ...mapBefore }; + const resolveFromRoot = (p) => normalizePath(path.resolve(root, p)); + if (map.file) map.file = resolveFromRoot(map.file); + map.sources = map.sources.map(resolveFromRoot); + return map; +} +async function getSource(source, filename, additionalData, enableSourcemap, sep = "") { + if (!additionalData) return { content: source }; + if (typeof additionalData === "function") { + const newContent = await additionalData(source, filename); + if (typeof newContent === "string") return { content: newContent }; + return newContent; + } + if (!enableSourcemap) return { content: additionalData + sep + source }; + const ms = new MagicString(source); + ms.appendLeft(0, sep); + ms.appendLeft(0, additionalData); + const map = ms.generateMap({ hires: "boundary" }); + map.file = filename; + map.sources = [filename]; + return { + content: ms.toString(), + map + }; +} +const createPreprocessorWorkerController = (maxWorkers) => { + const scss = scssProcessor(maxWorkers); + const less = lessProcessor(maxWorkers); + const styl = stylProcessor(maxWorkers); + const sassProcess = (environment, source, root, options, resolvers) => { + const opts = { ...options }; + opts.syntax = "indented"; + return scss.process(environment, source, root, opts, resolvers); + }; + const close = async () => { + await Promise.all([ + less.close(), + scss.close(), + styl.close() + ]); + }; + return { + ["less"]: less.process, + ["scss"]: scss.process, + ["sass"]: sassProcess, + ["styl"]: styl.process, + ["stylus"]: styl.process, + close + }; +}; +const normalizeMaxWorkers = (maxWorker) => { + if (maxWorker === void 0) return 0; + if (maxWorker === true) return void 0; + return maxWorker; +}; +const preprocessorSet = /* @__PURE__ */ new Set([ + "less", + "sass", + "scss", + "styl", + "stylus" +]); +function isPreProcessor(lang) { + return lang && preprocessorSet.has(lang); +} +const absoluteOrProtocolRelativeUrlRE = /^(?:[a-z]+:)?\/\//i; +const importEsbuild = createCachedImport(() => import("esbuild")); +const importLightningCSS = createCachedImport(() => import("lightningcss")); +async function compileLightningCSS(environment, id, src, deps, workerController, urlResolver) { + const { config } = environment; + const filename = removeDirectQuery(id); + let res; + try { + res = styleAttrRE.test(id) ? (await importLightningCSS()).transformStyleAttribute({ + filename, + code: Buffer.from(src), + targets: config.css.lightningcss?.targets, + minify: config.isProduction && !!config.build.cssMinify, + analyzeDependencies: true + }) : await (await importLightningCSS()).bundleAsync({ + ...config.css.lightningcss, + filename, + projectRoot: config.root, + resolver: { + async read(filePath) { + if (filePath === filename) return src; + const code = fs.readFileSync(filePath, "utf-8"); + const lang = CSS_LANGS_RE.exec(filePath)?.[1]; + if (isPreProcessor(lang)) { + const result = await compileCSSPreprocessors(environment, id, lang, code, workerController); + result.deps?.forEach((dep) => deps.add(dep)); + return result.code; + } else if (lang === "sss") return (await transformSugarSS(environment, id, code)).code; + return code; + }, + async resolve(id, from) { + const publicFile = checkPublicFile(id, environment.getTopLevelConfig()); + if (publicFile) return publicFile; + if (absoluteOrProtocolRelativeUrlRE.test(id)) return { external: id }; + const atImportResolvers = getAtImportResolvers(environment.getTopLevelConfig()); + const lang = CSS_LANGS_RE.exec(from)?.[1]; + let resolver; + switch (lang) { + case "css": + case "sss": + case "styl": + case "stylus": + case void 0: + resolver = atImportResolvers.css; + break; + case "sass": + case "scss": + resolver = atImportResolvers.sass; + break; + case "less": + resolver = atImportResolvers.less; + break; + default: throw new Error(`Unknown lang: ${lang}`); + } + const resolved = await resolver(environment, id, from); + if (resolved) { + deps.add(resolved); + return resolved; + } + return id; + } + }, + minify: config.isProduction && !!config.build.cssMinify, + sourceMap: config.command === "build" ? !!config.build.sourcemap : config.css.devSourcemap, + analyzeDependencies: { preserveImports: true }, + cssModules: cssModuleRE.test(id) ? config.css.lightningcss?.cssModules ?? true : void 0 + }); + } catch (e) { + e.message = `[lightningcss] ${e.message}`; + if (e.loc) { + e.loc = { + file: e.fileName.replace(NULL_BYTE_PLACEHOLDER, "\0"), + line: e.loc.line, + column: e.loc.column - 1 + }; + try { + const friendlyMessage = getLightningCssErrorMessageForIeSyntaxes(fs.readFileSync(e.fileName, "utf-8")); + if (friendlyMessage) e.message += friendlyMessage; + } catch {} + } + throw e; + } + for (const warning of res.warnings) { + let msg = `[vite:css][lightningcss] ${warning.message}`; + msg += `\n${generateCodeFrame(src, { + line: warning.loc.line, + column: warning.loc.column - 1 + })}`; + environment.logger.warn(import_picocolors.default.yellow(msg)); + } + let css = decoder.decode(res.code); + for (const dep of res.dependencies) switch (dep.type) { + case "file": + deps.add(dep.filePath); + break; + case "glob": { + for (const file of globSync(dep.glob)) deps.add(file); + const files = globSync(dep.glob, { + absolute: true, + expandDirectories: false, + ignore: ["**/node_modules/**"] + }); + for (let i = 0; i < files.length; i++) deps.add(files[i]); + break; + } + case "url": { + let replaceUrl; + if (skipUrlReplacer(dep.url)) replaceUrl = dep.url; + else if (urlResolver) { + const [newUrl, resolvedId] = await urlResolver(dep.url, dep.loc.filePath.replace(NULL_BYTE_PLACEHOLDER, "\0")); + if (resolvedId) deps.add(resolvedId); + replaceUrl = newUrl; + } else replaceUrl = dep.url; + css = css.replace(dep.placeholder, () => replaceUrl.replaceAll("\"", "\\\"")); + break; + } + case "import": + css = css.replace(dep.placeholder, () => dep.url); + break; + default: throw new Error(`Unsupported dependency type: ${dep.type}`); + } + let modules; + if ("exports" in res && res.exports) { + modules = {}; + const sortedEntries = Object.entries(res.exports).sort((a, b) => a[0].localeCompare(b[0])); + for (const [key, value] of sortedEntries) { + modules[key] = value.name; + for (const c of value.composes) modules[key] += " " + c.name; + } + } + return { + code: css, + map: "map" in res ? res.map?.toString() : void 0, + modules + }; +} +function getLightningCssErrorMessageForIeSyntaxes(code) { + if (/[\s;{]\*[a-zA-Z-][\w-]+\s*:/.test(code)) return ".\nThis file contains star property hack (e.g. `*zoom`), which was used in the past to support old Internet Explorer versions. This is not a valid CSS syntax and will be ignored by modern browsers. \nWhile this is not supported by LightningCSS, you can set `css.lightningcss.errorRecovery: true` to strip these codes."; + if (/min-width:\s*0\\0/.test(code)) return ".\nThis file contains @media zero hack (e.g. `@media (min-width: 0\\0)`), which was used in the past to support old Internet Explorer versions. This is not a valid CSS syntax and will be ignored by modern browsers. \nWhile this is not supported by LightningCSS, you can set `css.lightningcss.errorRecovery: true` to strip these codes."; +} +const map = { + chrome: "chrome", + edge: "edge", + firefox: "firefox", + hermes: false, + ie: "ie", + ios: "ios_saf", + node: false, + opera: "opera", + rhino: false, + safari: "safari" +}; +const esMap = { + 2015: [ + "chrome49", + "edge13", + "safari10", + "ios10", + "firefox44", + "opera36" + ], + 2016: [ + "chrome50", + "edge13", + "safari10", + "ios10", + "firefox43", + "opera37" + ], + 2017: [ + "chrome58", + "edge15", + "safari11", + "ios11", + "firefox52", + "opera45" + ], + 2018: [ + "chrome63", + "edge79", + "safari12", + "ios12", + "firefox58", + "opera50" + ], + 2019: [ + "chrome73", + "edge79", + "safari12.1", + "ios12.1", + "firefox64", + "opera60" + ], + 2020: [ + "chrome80", + "edge80", + "safari14.1", + "ios14.5", + "firefox80", + "opera67" + ], + 2021: [ + "chrome85", + "edge85", + "safari14.1", + "ios14.5", + "firefox80", + "opera71" + ], + 2022: [ + "chrome94", + "edge94", + "safari16.4", + "ios16.4", + "firefox93", + "opera80" + ], + 2023: [ + "chrome110", + "edge110", + "safari16.4", + "ios16.4", + "firefox146", + "opera96" + ], + 2024: [ + "chrome119", + "edge119", + "safari17.4", + "ios17.4", + "firefox145", + "opera105" + ], + 2025: [ + "chrome136", + "edge136", + "safari26.0", + "ios26.0", + "firefox138", + "opera121" + ] +}; +const esRE = /es(6|\d{4})/; +const versionRE = /\d/; +const convertTargetsCache = /* @__PURE__ */ new Map(); +const convertTargets = (esbuildTarget) => { + if (!esbuildTarget) return {}; + const cached = convertTargetsCache.get(esbuildTarget); + if (cached) return cached; + const targets = {}; + const entriesWithoutES = arraify(esbuildTarget).flatMap((e) => { + const match = esRE.exec(e); + if (!match) return e; + const year = match[1] === "6" ? 2015 : Number(match[1]); + if (!esMap[year]) throw new Error(`Unsupported target "${e}"`); + return esMap[year]; + }); + for (const entry of entriesWithoutES) { + if (entry === "esnext") continue; + const index = entry.search(versionRE); + if (index >= 0) { + const browser = map[entry.slice(0, index)]; + if (browser === false) continue; + if (browser) { + const [major, minor = 0] = entry.slice(index).split(".").map((v) => parseInt(v, 10)); + if (!isNaN(major) && !isNaN(minor)) { + const version = major << 16 | minor << 8; + if (!targets[browser] || version < targets[browser]) targets[browser] = version; + continue; + } + } + } + throw new Error(`Unsupported target "${entry}"`); + } + convertTargetsCache.set(esbuildTarget, targets); + return targets; +}; +function resolveLibCssFilename(libOptions, root, packageCache) { + if (typeof libOptions.cssFileName === "string") return `${libOptions.cssFileName}.css`; + else if (typeof libOptions.fileName === "string") return `${libOptions.fileName}.css`; + const packageJson = findNearestMainPackageData(root, packageCache)?.data; + const name = packageJson ? getPkgName(packageJson.name) : void 0; + if (!name) throw new Error("Name in package.json is required if option \"build.lib.cssFileName\" is not provided."); + return `${name}.css`; +} +//#endregion +//#region src/node/plugins/modulePreloadPolyfill.ts +const modulePreloadPolyfillId = "vite/modulepreload-polyfill"; +const resolvedModulePreloadPolyfillId = "\0vite/modulepreload-polyfill.js"; +function modulePreloadPolyfillPlugin() { + return { + name: "vite:modulepreload-polyfill", + applyToEnvironment(environment) { + if (environment.config.isBundled) return viteModulePreloadPolyfillPlugin({ isServer: environment.config.consumer !== "client" }); + return true; + }, + resolveId: { + filter: { id: exactRegex(modulePreloadPolyfillId) }, + handler(_id) { + return resolvedModulePreloadPolyfillId; + } + }, + load: { + filter: { id: exactRegex(resolvedModulePreloadPolyfillId) }, + handler(_id) { + return ""; + } + } + }; +} +//#endregion +//#region src/node/plugins/html.ts +const htmlProxyRE = /[?&]html-proxy=?(?:&inline-css)?(?:&style-attr)?&index=(\d+)\.(?:js|css)$/; +const isHtmlProxyRE = /[?&]html-proxy\b/; +const inlineCSSRE = /__VITE_INLINE_CSS__([a-z\d]{8}_\d+)__/g; +const inlineImportRE = /(?]*type\s*=\s*(?:"importmap"|'importmap'|importmap)[^>]*>.*?<\/script>/is; +const importMapAppendRE = new RegExp([/[ \t]*]*type\s*=\s*(?:"module"|'module'|module)[^>]*>/i, /[ \t]*]*rel\s*=\s*(?:"modulepreload"|'modulepreload'|modulepreload)[\s\S]*?>/i].map((r) => r.source).join("|"), "i"); +const isHTMLProxy = (id) => isHtmlProxyRE.test(id); +const isHTMLRequest = (request) => htmlLangRE.test(request); +const htmlProxyMap = /* @__PURE__ */ new WeakMap(); +const htmlProxyResult = /* @__PURE__ */ new Map(); +function htmlInlineProxyPlugin(config) { + htmlProxyMap.set(config, /* @__PURE__ */ new Map()); + return { + name: "vite:html-inline-proxy", + resolveId: { + filter: { id: isHtmlProxyRE }, + handler(id) { + return id; + } + }, + load: { + filter: { id: isHtmlProxyRE }, + handler(id) { + const proxyMatch = htmlProxyRE.exec(id); + if (proxyMatch) { + const index = Number(proxyMatch[1]); + const url = cleanUrl(id).replace(normalizePath(config.root), ""); + const result = htmlProxyMap.get(config).get(url)?.[index]; + if (result) return { + ...result, + moduleSideEffects: true + }; + else throw new Error(`No matching HTML proxy module found from ${id}`); + } + } + } + }; +} +function addToHTMLProxyCache(config, filePath, index, result) { + if (!htmlProxyMap.get(config)) htmlProxyMap.set(config, /* @__PURE__ */ new Map()); + if (!htmlProxyMap.get(config).get(filePath)) htmlProxyMap.get(config).set(filePath, []); + htmlProxyMap.get(config).get(filePath)[index] = result; +} +function addToHTMLProxyTransformResult(hash, code) { + htmlProxyResult.set(hash, code); +} +const noInlineLinkRels = /* @__PURE__ */ new Set([ + "icon", + "apple-touch-icon", + "apple-touch-startup-image", + "manifest" +]); +const isAsyncScriptMap = /* @__PURE__ */ new WeakMap(); +function nodeIsElement(node) { + return node.nodeName[0] !== "#"; +} +function traverseNodes(node, visitor) { + if (node.nodeName === "template") node = node.content; + visitor(node); + if (nodeIsElement(node) || node.nodeName === "#document" || node.nodeName === "#document-fragment") node.childNodes.forEach((childNode) => traverseNodes(childNode, visitor)); +} +async function traverseHtml(html, filePath, warn, visitor) { + const { parse, ErrorCodes } = await import("./dist.js"); + const warnings = {}; + traverseNodes(parse(html, { + scriptingEnabled: false, + sourceCodeLocationInfo: true, + onParseError: (e) => { + handleParseError(e, ErrorCodes, html, filePath, warnings); + } + }), visitor); + for (const message of Object.values(warnings)) warn(import_picocolors.default.yellow(`\n${message}`)); +} +function getScriptInfo(node) { + let src; + let srcSourceCodeLocation; + let isModule = false; + let isAsync = false; + let isIgnored = false; + for (const p of node.attrs) { + if (p.prefix !== void 0) continue; + if (p.name === "src") { + if (!src) { + src = p; + srcSourceCodeLocation = node.sourceCodeLocation?.attrs.src; + } + } else if (p.name === "type" && p.value === "module") isModule = true; + else if (p.name === "async") isAsync = true; + else if (p.name === "vite-ignore") isIgnored = true; + } + return { + src, + srcSourceCodeLocation, + isModule, + isAsync, + isIgnored + }; +} +const attrValueStartRE = /=\s*(.)/; +function overwriteAttrValue(s, sourceCodeLocation, newValue) { + const srcString = s.slice(sourceCodeLocation.startOffset, sourceCodeLocation.endOffset); + const valueStart = attrValueStartRE.exec(srcString); + if (!valueStart) throw new Error(`[vite:html] internal error, failed to overwrite attribute value`); + const wrapOffset = valueStart[1] === "\"" || valueStart[1] === "'" ? 1 : 0; + const valueOffset = valueStart.index + valueStart[0].length - 1; + s.update(sourceCodeLocation.startOffset + valueOffset + wrapOffset, sourceCodeLocation.endOffset - wrapOffset, newValue); + return s; +} +function removeViteIgnoreAttr(s, sourceCodeLocation) { + const loc = sourceCodeLocation.attrs?.["vite-ignore"]; + if (loc) s.remove(loc.startOffset, loc.endOffset); + return s; +} +/** +* Format parse5 @type {ParserError} to @type {RollupError} +*/ +function formatParseError(parserError, id, html) { + return { + code: parserError.code, + message: `parse5 error code ${parserError.code}`, + frame: generateCodeFrame(html, parserError.startOffset, parserError.endOffset), + loc: { + file: id, + line: parserError.startLine, + column: parserError.startCol + } + }; +} +function handleParseError(parserError, errorCodes, html, filePath, warnings) { + switch (parserError.code) { + case errorCodes.missingDoctype: return; + case errorCodes.abandonedHeadElementChild: return; + case errorCodes.duplicateAttribute: return; + case errorCodes.nonVoidHtmlElementStartTagWithTrailingSolidus: return; + case errorCodes.unexpectedQuestionMarkInsteadOfTagName: return; + } + const parseError = formatParseError(parserError, filePath, html); + warnings[parseError.code] ??= `Unable to parse HTML; ${parseError.message}\n at ${parseError.loc.file}:${parseError.loc.line}:${parseError.loc.column}\n` + parseError.frame; +} +/** +* Collects CSS files for a chunk by traversing its imports depth-first, +* using a cache to avoid re-analyzing chunks while still returning the +* correct files when the same chunk is reached via different entry points. +*/ +function getCssFilesForChunk(chunk, bundle, analyzedImportedCssFiles, seenChunks = /* @__PURE__ */ new Set(), seenCss = /* @__PURE__ */ new Set()) { + if (seenChunks.has(chunk.fileName)) return []; + seenChunks.add(chunk.fileName); + if (analyzedImportedCssFiles.has(chunk)) { + const additionals = analyzedImportedCssFiles.get(chunk).filter((file) => !seenCss.has(file)); + additionals.forEach((file) => seenCss.add(file)); + return additionals; + } + const allFiles = []; + const filteredFiles = []; + chunk.imports.forEach((file) => { + const importee = bundle[file]; + if (importee?.type === "chunk") { + const importeeCss = getCssFilesForChunk(importee, bundle, analyzedImportedCssFiles, seenChunks, seenCss); + filteredFiles.push(...importeeCss); + if (analyzedImportedCssFiles.has(importee)) allFiles.push(...analyzedImportedCssFiles.get(importee)); + else allFiles.push(...importeeCss); + } + }); + chunk.viteMetadata.importedCss.forEach((file) => { + allFiles.push(file); + if (!seenCss.has(file)) { + seenCss.add(file); + filteredFiles.push(file); + } + }); + analyzedImportedCssFiles.set(chunk, unique(allFiles)); + return filteredFiles; +} +/** +* Compiles index.html into an entry js module +*/ +function buildHtmlPlugin(config) { + const [preHooks, normalHooks, postHooks] = resolveHtmlTransforms(config.plugins); + preHooks.unshift(injectCspNonceMetaTagHook(config)); + preHooks.unshift(preImportMapHook(config)); + preHooks.push(htmlEnvHook(config)); + postHooks.push(injectNonceAttributeTagHook(config)); + postHooks.push(postImportMapHook(config)); + const processedHtml = perEnvironmentState(() => /* @__PURE__ */ new Map()); + const isExcludedUrl = (url) => url[0] === "#" || isExternalUrl(url) || isDataUrl(url); + isAsyncScriptMap.set(config, /* @__PURE__ */ new Map()); + return { + name: "vite:build-html", + applyToEnvironment(environment) { + return environment.config.isBundled; + }, + transform: { + filter: { id: /\.html$/ }, + async handler(html, id) { + id = normalizePath(id); + const relativeUrlPath = normalizePath(path.relative(config.root, id)); + const publicPath = `/${relativeUrlPath}`; + const publicBase = getBaseInHTML(relativeUrlPath, config); + const publicToRelative = (filename) => publicBase + filename; + const toOutputPublicFilePath = (url) => toOutputFilePathInHtml(url.slice(1), "public", relativeUrlPath, "html", config, publicToRelative); + const nodeStartWithLeadingWhitespace = (node) => { + const startOffset = node.sourceCodeLocation.startOffset; + if (startOffset === 0) return 0; + const lineStartOffset = startOffset - node.sourceCodeLocation.startCol; + let isLineEmpty = false; + try { + isLineEmpty = !s.slice(Math.max(0, lineStartOffset), startOffset).trim(); + } catch {} + return isLineEmpty ? lineStartOffset : startOffset; + }; + html = await applyHtmlTransforms(html, preHooks, this, { + path: publicPath, + filename: id + }); + let js = ""; + const s = new MagicString(html); + const scriptUrls = []; + const styleUrls = []; + let inlineModuleIndex = -1; + let everyScriptIsAsync = true; + let someScriptsAreAsync = false; + let someScriptsAreDefer = false; + const assetUrlsPromises = []; + const namedOutput = Object.keys(config.build.rolldownOptions.input || {}); + const processAssetUrl = async (url, shouldInline) => { + if (url !== "" && !namedOutput.includes(url) && !namedOutput.includes(removeLeadingSlash(url))) try { + return await urlToBuiltUrl(this, url, id, shouldInline); + } catch (e) { + if (e.code !== "ENOENT") throw e; + } + return url; + }; + const setModuleSideEffectPromises = []; + await traverseHtml(html, id, config.logger.warn, (node) => { + if (!nodeIsElement(node)) return; + let shouldRemove = false; + if (node.nodeName === "script") { + const { src, srcSourceCodeLocation, isModule, isAsync, isIgnored } = getScriptInfo(node); + if (isIgnored) removeViteIgnoreAttr(s, node.sourceCodeLocation); + else { + const url = src && src.value; + const isPublicFile = !!(url && checkPublicFile(url, config)); + if (isPublicFile) overwriteAttrValue(s, srcSourceCodeLocation, partialEncodeURIPath(toOutputPublicFilePath(url))); + if (isModule) { + inlineModuleIndex++; + if (url && !isExcludedUrl(url) && !isPublicFile) { + setModuleSideEffectPromises.push(this.resolve(url, id).then((resolved) => { + if (!resolved) return Promise.reject(/* @__PURE__ */ new Error(`Failed to resolve ${url} from ${id}`)); + const moduleInfo = this.getModuleInfo(resolved.id); + if (moduleInfo) moduleInfo.moduleSideEffects = true; + else if (!resolved.external) return this.load({ + ...resolved, + moduleSideEffects: true + }).then(() => {}); + })); + js += `\nimport ${JSON.stringify(url)}`; + shouldRemove = true; + } else if (node.childNodes.length) { + const contents = node.childNodes.pop().value; + addToHTMLProxyCache(config, id.replace(normalizePath(config.root), ""), inlineModuleIndex, { code: contents }); + js += `\nimport "${id}?html-proxy&index=${inlineModuleIndex}.js"`; + shouldRemove = true; + } + everyScriptIsAsync &&= isAsync; + someScriptsAreAsync ||= isAsync; + someScriptsAreDefer ||= !isAsync; + } else if (url && !isPublicFile) { + if (!isExcludedUrl(url)) config.logger.warn(`